Classificação: avançando em classificadores

Apresentando o curso e o instrutor

Olá, pessoal! Tudo bem? Sejam bem-vindas e bem-vindos ao nosso curso de classificação avançada com classificadores. Antes de começar, vou me apresentar. Meu nome é Ariel Velardo e vou acompanhar você ao longo deste processo.

Audiodescrição: Sou um homem de pele parda, com cabelo cacheado e barba curta. Neste momento estou com um relógio no pulso esquerdo e usando um moletom verde. Atrás de mim há uma estante com alguns livros e, à minha esquerda, outra estante com alguns objetos.

Falando sobre o curso, vamos desenvolver um projeto completo de classificação e conhecer diferentes técnicas. Vamos entender o que são métodos ou modelos de Ensemble (conjunto). Também vamos aprender a otimizar hiperparâmetros para melhorar o desempenho do modelo. Exploraremos várias estratégias mais avançadas de classificação em relação ao que foi trabalhado no curso anterior.

Apresentando-me um pouco melhor: Meu nome é Ariel Velardo, sou cientista de dados e, ocasionalmente, atuo como líder técnico. Também sou professor universitário na FIAP. Trabalho na área de dados desde 2018, com foco em ciência de dados, analytics e machine learning (aprendizado de máquina). Já atuei em projetos de crédito, cobrança, forecasting (previsão), modelos de propensão, NLP (Processamento de Linguagem Natural) e visão computacional. Estarei com você ao longo de todo este processo.

Vou deixar também meu LinkedIn, caso você tenha interesse em me seguir, e meu GitHub para consulta. Ele não está tão atualizado, mas é possível ver alguns projetos pessoais ou mais acadêmicos.

Contextualizando o problema de inadimplência

Neste curso, para dar contexto, vamos tentar responder à pergunta: Conseguimos antecipar a inadimplência?

Vamos definir inadimplência de forma simples: quando existe uma obrigação financeira com data específica para pagamento — por exemplo, todo dia 5 do mês — e o pagamento não é realizado, no dia seguinte o sistema pode registrar a inadimplência, de acordo com a regra de negócio vigente. Regras de negócio variam entre empresas, mas, em essência, inadimplência é o não cumprimento da obrigação financeira com a instituição.

Trabalharemos com duas classes:

• Classe 0: não inadimplente, quem pagou.
• Classe 1: inadimplente, nosso target (alvo) de interesse, quem deixou de pagar.

Nossa base possui cerca de 22,12% de clientes inadimplentes, aproximadamente 22% que não estão pagando. Ou seja, temos uma base desbalanceada, o que exigirá técnicas apropriadas ao longo do projeto.

Estamos lidando com um desbalanceamento que não é grave; há cenários muito piores. Em detecção de fraudes, por exemplo, podemos ter 99% para 1%. Aqui, arredondando, temos aproximadamente 80/20, o que é bem administrável.

Vamos trabalhar com esta base de dados, que será disponibilizada para vocês e também pode ser obtida no Kaggle. Vocês terão acesso a ela.

Detalhando o plano das aulas e a avaliação

O que vamos construir nessas seis aulas:

• Entendimento do problema e das métricas necessárias para avaliação. Algumas delas vocês já devem conhecer, mas nós vamos nos aprofundar.
• Conceito de benchmark (referência) e definição de um modelo de referência que buscaremos superar continuamente.
• Métodos ensemble (conjunto): o que são e como funcionam, inclusive na teoria. Vamos abordar especificamente:
  • Bagging (agregação por bootstrap),
  • Boosting (impulsionamento),
  • Random Forest (floresta aleatória),
  • XGBoost (impulsionamento por gradiente extremo).
• Otimização de hiperparâmetros: vamos pegar um modelo e melhorá-lo ajustando seus hiperparâmetros para obter métricas superiores. Faremos isso principalmente com Optuna, comentando brevemente outras técnicas.
• Desbalanceamento: como o desbalanceamento afeta o modelo, por que isso ocorre e como lidar com o problema.
• Limiar de decisão: como a variação do limiar do modelo pode gerar resultados possivelmente melhores. Em alguns casos, a métrica global pode não melhorar, mas, ao ajustar o limiar em alinhamento com a área de negócios, podemos otimizar o resultado prático.
• Modelos semi-supervisionados e interpretação de modelos. Não vamos nos aprofundar muito nessa parte, mas ela é importante e será abordada.
• Seleção de um modelo final. Conduziremos tudo de forma científica: testaremos alternativas e manteremos a melhor ao longo do processo.
• Implantação do modelo final em uma aplicação com Streamlit. O curso não tem foco em Streamlit; queremos que o foco esteja em modelos de classificação mais avançados. Portanto, chegaremos com uma aplicação pronta e disponibilizaremos um código bem comentado sobre seu funcionamento. Nós apenas não construiremos a aplicação passo a passo, pois esse não é o foco do curso.

Ao final, vamos trabalhar com uma base de dados pessoal que ficará intocada. Vocês provavelmente já aprenderam a separar entre treino e teste; aqui criaremos outra separação. Quando chegarmos a esse momento, explicaremos melhor. Sempre utilizaremos treino e teste e manteremos uma parte da base intocada para, depois, realizarmos um teste de verdade.

É isso: é o que vamos trabalhar nessas seis aulas. Esperamos que vocês acompanhem até o final, aprendam bastante e temos certeza de que será uma jornada muito proveitosa. Nos vemos!

Relembrando a matriz de confusão e motivando métricas

Vamos retomar um ponto do vídeo anterior. Nele, vimos como uma classificação pode terminar em quatro situações diferentes: verdadeiro positivo, verdadeiro negativo, falso positivo e falso negativo. Portanto, temos dois tipos de acerto e dois tipos de erro.

A matriz de confusão nos ajuda bastante a organizar esses acertos e erros. No entanto, apenas olhar para esses quatro números ainda não responde tudo para nós. Agora, queremos transformar esses resultados em métricas que vão nos ajudar a entender melhor o comportamento do nosso modelo.

Definindo precisão e revocação com analogias

Duas métricas são extremamente importantes: chamamos de precision (precisão) e de recall (revocação). Uma forma de pensar nelas é por meio de uma analogia com pescaria. Imagine primeiro que estamos pescando com um arpão: miramos um peixe específico e fazemos uma captura bastante seletiva. Provavelmente vamos capturar exatamente o que procurávamos, mas também vamos capturar menos peixes no total. Essa é a ideia de precision (precisão): entre tudo o que marcamos como positivo, quanto realmente era positivo? No nosso problema, a pergunta seria: entre as pessoas clientes que o modelo marcou como inadimplentes, quantas realmente eram inadimplentes? Esse é o precision (precisão).

Agora, imagine que, em vez do arpão, jogamos uma rede. Com a rede, conseguimos alcançar muito mais peixes. Temos uma chance maior de capturar os peixes que estavam lá, mas também podemos trazer junto coisas indesejadas, como pedras, algas, garrafas e outros itens que não são peixe. Essa é a ideia de recall (revocação): entre todos os positivos que realmente existiam, quantos conseguimos capturar? No nosso caso: entre todas as pessoas clientes que de fato se tornaram inadimplentes, quantas o modelo conseguiu identificar? Buscar mais recall (revocação) pode significar aceitar mais falsos positivos.

Resumindo: o precision (precisão) olha para o que marcamos como positivo e verifica o quanto disso era realmente positivo; o recall (revocação) olha para o total de positivos que existiam e verifica qual fração conseguimos capturar. Essa parte é extremamente importante para mantermos o conceito claro.

Ajustando o limiar e analisando o trade-off

Observemos agora um gráfico: cada ponto nesse gráfico representa um threshold (limiar). Cada ponto corresponde a uma regra diferente para decidir a partir de qual probabilidade uma pessoa cliente passa a ser classificada como positiva (1) ou negativa (0). Quando alteramos esse corte, o precision (precisão) e o recall (revocação) mudam. Em geral, ao aumentar o precision (precisão), diminuímos o recall (revocação); ao aumentar o recall (revocação), diminuímos o precision (precisão).

Se conseguimos um precision (precisão) maior, erramos menos entre as pessoas clientes que marcamos como positivas. Se conseguimos um recall (revocação) maior, encontramos uma parcela maior dos casos positivos que realmente existem. Voltando à pescaria, podemos ser mais seletivos como com o arpão (mais precision (precisão)) ou tentar alcançar mais casos usando a rede (mais recall (revocação)).

Não existe uma configuração que seja automaticamente melhor para todo tipo de problema. Esse equilíbrio depende do que queremos fazer com o modelo. Os valores do gráfico são ilustrativos; não significa que nosso modelo atingirá esses valores quando começarmos a executar. Quando estivermos implementando de fato, esse gráfico fará muito mais sentido.

Resumindo desempenho com F1 e precisão média

Também temos o F1-score (pontuação F1), que combina precision (precisão) e recall (revocação). Ele é útil quando queremos resumir o equilíbrio entre essas duas métricas em um determinado ponto de corte. Trata-se de uma média harmônica entre as duas.

Já o Average Precision (precisão média), ou AP, resume o comportamento do modelo ao longo de toda a curva de precision (precisão)–recall (revocação). Por isso, no resultado final, o AP será a principal métrica para compararmos os modelos deste projeto. A lógica será: primeiro comparamos os modelos pela capacidade de separar os casos (usando o AP) e, depois, decidimos qual ponto de corte faz mais sentido.

Se olharmos a melhor curva no gráfico, por exemplo a curva verde, ela tem o melhor AP (Average Precision (precisão média)). Quanto mais a curva estiver voltada para o canto superior direito, melhor será para nós, pois isso indica melhor precision (precisão) e melhor recall (revocação). Algumas curvas são mais retas e apresentam aproximadamente recall (revocação) em torno de 0,5; quanto mais tendendo a 1, melhor para nós.

Vamos agora para o nosso...

Iniciando a prática no VS Code

No VS Code, vamos começar a prática. Chegamos aqui e há algo que precisamos fazer. Vocês já sabem como está o ambiente, tudo configurado corretamente. Estes são os nossos notebooks (cadernos). Eu tenho todos aqui, mas vocês os receberão conforme o andamento do curso. Algo está destacado em amarelo; depois explicaremos o motivo.

Vamos nos situar primeiro no que é mais importante. Está aberto em um notebook (caderno), mas o que vamos utilizar aqui é o conjunto de problemas de benchmark (referência). Algumas partes ficarão prontas; outras vamos programar. O que ficará pronto? Tudo que não for importante especificamente para este curso — por exemplo, criação de gráficos e afins, coisas que não dizem respeito direto ao material — deixaremos pronto. O que for essencial para este curso, vamos programar juntos.

Vamos fechar esta biblioteca que não é necessária agora. Primeiro, vamos ativar a nossa VM (VM, máquina virtual). Com ela ativada, podemos fechá-la visivelmente porque não precisamos mantê-la aberta na interface. Em seguida, vamos garantir que o nosso kernel (núcleo de execução) está ativado. Vamos executar esta célula, pois ela carregará todas as bibliotecas necessárias e também a base de dados.

Apresentando bibliotecas e dados do projeto

Podemos ver que estamos carregando a base de dados e diversas bibliotecas que utilizaremos ao longo do curso. Não vamos comentar todas em detalhe agora; faremos uma passada rápida:

• Temos um ColumnTransformer, usado para transformação de colunas (vamos entender o funcionamento e utilizá-lo já).
• Dois modelos: RandomForestClassifier e LogisticRegression. Neste vídeo, não entraremos em detalhes práticos de como funcionam; deixaremos isso para os próximos vídeos.
• Algumas métricas, como average_precision, precision e recall.
• O train_test_split.
• O Pipeline, que ajudará na organização do fluxo do que faremos.
• Bibliotecas para alguns pré-processamentos necessários.

Também temos funções auxiliares previamente preparadas, entre as quais a que separa colunas nominais do nosso dataframe (quadro de dados), como sexo, escolaridade e estado civil.

Vamos rodar a próxima parte para dar uma olhada nas colunas do nosso dataframe (quadro de dados). Não faremos análise exploratória agora; este não é o foco.

Temos a variável alvo (inadimplente). Quando estivermos manipulando a base, cortaremos essa coluna para evitar vazamento de informação. Temos também um dataframe (quadro de dados) de resultados com aproximadamente trinta mil linhas, vinte e cinco variáveis, sem valores ausentes e sem duplicatas. A taxa de inadimplência é de 22,12%. Entre as informações, há limite de crédito, idade, valor da fatura e valor pago.

Separando atributos e alvo

Agora, vamos começar de fato a escrever, dividindo o nosso código. Já existe uma parte pronta; depois explicaremos o que ela faz. Nesta primeira etapa, vamos separar os dados em conjuntos. Primeiro, vamos separar em variáveis de atributos (as variáveis explicativas) e variável alvo (a variável target).

Faremos assim:

• Definiremos X a partir do nosso dataframe (quadro de dados) dados, removendo colunas com drop(columns=...).

Para implementar essa primeira parte, criamos a matriz de atributos X removendo o identificador e a coluna alvo do dataframe:

X = dados.drop(columns=['id_cliente', 'inadimplente'])

• Quais colunas removeremos de X? Pelo menos duas:
  • id_cliente, por ser apenas um identificador que não agrega informação ao modelo e pode até atrapalhar.
  • A coluna de resposta (variável alvo), pois o modelo não deve “aprender” diretamente com a resposta.
• Definiremos y como sendo apenas a coluna de resposta (a nossa variável target).

Em seguida, adicionamos a definição de y, consolidando o par X e y que usaremos nas próximas etapas:

X = dados.drop(columns=['id_cliente', 'inadimplente'])
y = dados['inadimplente']

Separamos X e y. No próximo vídeo, continuaremos esta etapa (parte 1.1) para separar X e y em mais grupos. Isso fará sentido na sequência. Nos vemos no próximo vídeo.

Introduzindo a separação em conjuntos

Vamos continuar a segunda parte. Já separamos os dois primeiros conjuntos, nos quais definimos as variáveis explicativas e a variável target (alvo), x e y. Agora, vamos separar em mais conjuntos.

Precisamos explicar essa etapa de separação dos conjuntos. Já compreendemos que separam os dados em treino e teste. Aqui, utilizaremos um método um pouco diferente: treino, validação e teste. O que são esses conjuntos?

Vamos usar uma analogia. Imagine que vamos fazer o vestibular ou o Enem no final do ano. Nesse período, utilizamos apostila, livro, internet e videoaula: estamos treinando. Essa é a situação do conjunto de treino. Depois, realizamos simulados semanalmente, quinzenalmente ou mensalmente, conforme possível: estamos no ambiente de validação, verificando o que precisa ser ajustado. Por exemplo, identificamos dificuldades em questões de Brasil Colônia ou em modelos morfoclimáticos de Geografia e ajustamos o que precisamos estudar. No final do ano, fazemos o vestibular ou o Enem: essa é a situação do conjunto de teste. Portanto, temos treino, validação e teste.

Qual é o ponto? Quando treinamos o modelo, verificamos se ele está acertando utilizando o conjunto de validação e vamos ajustando o modelo, realizando um ajuste fino. Ajustamos os hiperparâmetros e verificamos quais parâmetros funcionam para maximizar as métricas de interesse do modelo. Assim, treinamos o modelo para melhorar o desempenho no conjunto de validação.

Precisamos, então, reservar um conjunto de teste e deixá-lo intocado. O modelo não terá acesso a esse conjunto durante o treinamento; vamos treiná-lo para obter bom desempenho no conjunto de validação. Depois que o treinamento e os ajustes estiverem concluídos, verificaremos se, com esse conjunto de dados que o modelo nunca viu, ele consegue generalizar e obter bons resultados. Esse é o objetivo.

Vamos criar esses conjuntos agora e, depois, eles ficarão intocados; não vamos mais mexer neles.

Criando os conjuntos com train_test_split

Mostraremos como criar esses conjuntos. A função train_test_split separa apenas em dois conjuntos. Portanto, faremos em etapas. Primeiro, vamos separar em x_treino_validacao e x_teste, e em seguida em y_treino_validacao e y_teste. Em seguida, usaremos novamente a lógica de separação para obter os subconjuntos desejados. Faremos isso com train_test_split, passando as variáveis necessárias, como x.

Ajustamos a convenção de nomes das variáveis: utilizamos X em maiúsculo para as variáveis explicativas e y em minúsculo para a variável alvo. Para refletir essa convenção no código, definimos X e y desta forma:

X = dados.drop(columns=['id_cliente', 'inadimplente'])
y = dados['inadimplente']

Em seguida, definimos o parâmetro test_size para controlar como os dados serão divididos. Com test_size igual a 0.2 (ou 0.20), obtemos 80% dos dados em X_treino_validacao e y_treino_validacao, e 20% em X_teste e y_teste.

Incluímos o parâmetro stratify para estratificar a divisão com base na variável de interesse, inadimplente. Descobrimos que a taxa de inadimplência é de 22,12%, e queremos manter essa proporção em todos os conjuntos. Isso evita, por exemplo, ter um conjunto de treino com distribuição 50/50 e outro quase sem exemplos positivos, o que não é desejável.

Inserimos as vírgulas necessárias na chamada da função e configuramos random_state com o valor 42. Com esses parâmetros, a primeira separação fica assim:

X_treino_validacao, X_teste, y_treino_validacao, y_teste = train_test_split(
    X,
    y,
    test_size=0.20,
    stratify=y,
    random_state=42,
)

Executamos o primeiro bloco para verificar possíveis erros. Um erro ocorreu devido ao argumento columns estar escrito de forma incorreta; corrigimos para columns e o bloco passou a executar corretamente.

Realizando a segunda divisão e salvando resultados

Na sequência, realizamos uma nova divisão. Já temos X_treino_validacao, X_teste, y_treino_validacao e y_teste. Agora, utilizamos X_treino_validacao como X de entrada e y_treino_validacao como y, estratificando com base em y_treino_validacao. Definimos test_size como 0.25. Como previamente separamos 80% para treino/validação, ao aplicar 25% sobre esses 80%, obtemos 20% para validação e 60% para treino em relação ao conjunto original. No código, essa segunda divisão fica assim:

X_treino, X_validacao, y_treino, y_validacao = train_test_split(
    X_treino_validacao,
    y_treino_validacao,
    test_size=0.25,
    stratify=y_treino_validacao,
    random_state=42,
)

Com isso, produzimos X_treino, X_validacao, y_treino e y_validacao, além de já termos X_teste e y_teste. Na primeira divisão, utilizamos o conjunto original. Nesta etapa, utilizamos o “novo conjunto original”, isto é, o subconjunto X_treino_validacao e y_treino_validacao. Executamos essa parte e o processo ocorreu rapidamente e sem erros.

Esta etapa também serve para salvar os conjuntos resultantes. Após salvar, verificamos as proporções: 20% para teste, 20% para validação e 60% para treino. Obtivemos 18.000 linhas para treino, 6.000 linhas para validação e 6.000 linhas para teste, mantendo em todos os conjuntos a taxa de inadimplência próxima de 22,12%.

Confirmamos que tudo foi salvo corretamente. Foram geradas as bases processadas: teste, treino e validacao. É importante salvar: ao salvar, o item fica em destaque amarelo e, na parte inferior, é exibido o comando para realizar o commit, com um nome sugerido. Caso preferido, é possível alterar esse nome.

Salvando as alterações no Git e GitHub

Com os conjuntos de treino, validação e teste preparados, podemos registrar essa etapa no Git e enviar as alterações para o GitHub.

No terminal, dentro da pasta do projeto, primeiro verificamos os arquivos modificados:

git status

Depois, adicionamos as alterações que queremos versionar. Para adicionar todos os arquivos modificados e não ignorados:

git add .

Registramos as alterações com uma mensagem que identifica o que foi desenvolvido:

git commit -m "Separa dados em treino, validacao e teste"

Por fim, enviamos o commit para o repositório remoto:

git push

Assim, mantemos o histórico do projeto organizado e conseguimos acompanhar sua evolução no GitHub.

Nos vemos no próximo vídeo.