Balanceamento de classes

Vamos comparar a frequência de cada classe (eleito/ não eleito) nos dados de treino. O interesse é identificar se há uma classe que é bem mais recorrente do que outra nos dados de treino.

source("../color_pallet.R")
library(ggplot2)

plot_classes = function(data) {
 classes = data %>% 
  select(situacao) %>%
  group_by(situacao) %>%
  summarise(count=n())

  ylim = 7000 
     
  ggplot(classes, aes(x=situacao, y=count, fill=situacao)) +
    geom_bar(stat = "identity") +
    scale_fill_drsimonj(discrete = TRUE, palette = "hot") +
    scale_y_continuous(limits = c(0, ylim))

}

plot_classes(train_raw)

A partir da visualização acima, fica claro que há um desbalanceamento. As classes aparecem desproporcionalmente nos dados de treino (há quase 7 vezes mais observações classificadas como não eleito do que como eleito).
Um dos efeitos colaterais que este desbalanceamento de classes pode causar no classificador é reduzir sua acurácia, visto que o classificador ficará enviesado.
Para tratar este tipo de problema, há algumas abordagens geralmente utilizadas: 1. Alterar a métrica de avaliação modelo de acurácia para precision e recall.
2. Reamostragem do dataset, sendo possível usar alguma das seguintes técnicas: - ROSE: Random Over-Sampling Examples. - SMOTE: Synthetic Minority Over-Sampling Technique; - Oversampling: criação de observações da classe minoritária; - Undersampling: remoção de algumas observações da classe majoritária;

Vamos testar algumas delas.

library(ROSE)

opt_rose = ROSE(situacao ~ ., data  = train_raw)$data
plot_classes(opt_rose)

library(DMwR)

opt_smote = SMOTE(situacao ~ ., data  = train_raw)                         
plot_classes(opt_smote)

require(caret)

opt_oversampling = upSample(x = train_raw[,], 
                            y = train_raw$situacao)  

plot_classes(opt_oversampling)

opt_undersampling = 
  downSample(x = train_raw[, -ncol(train_raw)], 
             y = train_raw$situacao)  %>%
  mutate(situacao = Class)

plot_classes(opt_undersampling)

train = opt_rose

Transformando dados

Eliminando algumas variáveis que não serão relevantes para a classificação.

train = train_raw %>% select(-ano, -sequencial_candidato, -nome, -cargo)
test = test %>% select(-ano, sequencial_candidato, -nome, -cargo)
rm(train_raw)

Vamo também transformar algumas variáveis categóricas em variáveis númericas.

genre_cat_to_id = function(m_genre) {
  return(ifelse(m_genre == "MASCULINO", 0, 1))
}

categoric_to_id = function(data) {
  require(dplyr)
  trasnformed = data %>% 
    mutate(sexo = genre_cat_to_id(sexo),
    grau = as.integer(as.factor(grau)),
    estado_civil = as.integer(as.factor(estado_civil)),
    ocupacao = as.integer(as.factor(ocupacao)),
    partido = as.integer(as.factor(partido)),
    uf = as.integer(as.factor(uf)))
  return(trasnformed)
}

train = train %>% categoric_to_id
test = test %>% categoric_to_id 

Dataset de validação

Iremos retirar um subconjunto dos dados de treino e vamos chamá-lo de dados de validação, que usaremos para avaliar resultados de nossos modelos.

## set seed to make partition reproducible
set.seed(123)

create_train_validate = function(dataframe) {
  assignment = sample(
    1:2, size = nrow(dataframe), 
    prob = c(0.8, 0.2), replace = TRUE)

  smp_train = dataframe[assignment == 1, ]
  smp_valid = dataframe[assignment == 2, ]
  
  return(list(smp_train, smp_valid))
}

splitted = create_train_validate(train)
train = splitted[[1]]
validation_set = splitted[[2]]

KNN

O modeo KNN (k-nearest neighbors ou k vizinhos mais próximos) é um algoritmo que tem como premissa que, dado um conjunto de observações distribuídas como vetores num plano multidimensional (em que cada dimensão corresponde a uma feature das observações), observações próximas tendem a pertencer à mesma classe. O valor K corresponde justamente ao número de vizinhos próximos a se considerar.

library(caret)

n_neighbors_grid = expand.grid(k = 1:20) 
fit_control_knn = trainControl(method="repeatedcv", repeats = 3)

set.seed(123)
model.knn = 
  train(formula,
        data = train,
        method = "knn",
        trControl = fit_control_knn,
        tuneGrid = n_neighbors_grid,
        tuneLength = 20,
        preProcess = c('scale', 'center'),
        metric = "Accuracy",
        na.action = na.omit)

plot(model.knn, print.thres = 0.5, type="S")

Regressão Logística

Na Regressão Logística, ao inveś de buscar-se predizer um valor diretamente, o algoritmo estima uma probabilidade de uma instância pertencer a uma determinada classe. Se para uma instância essa estimativa for maior que 50%, por exemplo, então o modelo prevê que esta instância pertence a essa classe.

require(caret)

fit_control = trainControl(method = "repeatedcv",
                           number = 10,
                           repeats = 5,
                           classProbs = TRUE)

set.seed(123)
model.logistic = train(formula,
                 data = train,
                 method="glm",
                 family="binomial",
                 trControl = fit_control,
                 tuneLength = 20,
                 preProcess = c("scale", "center"),                 
                 na.action = na.omit)

Árvore de Decisão

Esse modelo parrte da noção fundamental da ciência da computação de “dividir e conquistar”. O objetivo da aprendizagem é descobrir quais perguntas fazer, em que ordem perguntar e qual a resposta a prever depois de fazer perguntas suficientes. A árvore de decisão é assim chamada porque podemos escrever nosso conjunto de perguntas e suposições em um formato de árvore. Podemos mapear essas perguntas para as features do nosso conjunto de dados e as repostas para essas perguntas para os valores dessas features. Em um formato possível de uma árvore, por exemplo, cada nó não terminal tem dois filhos: a criança esquerda especifica o que fazer se a resposta à pergunta for “não” e o filho à direita especifica o que fazer se for “sim”. Grosso modo, uma nova instância a ser classificada percorre um caminho na árvore, desde à raiz, respondendo às perguntas, até chegar a um nó que não tiver filhos, e aí então essa instância será classificada de acordo com o rótulo desse nó.

require(caret)
require(rpart)

mFitControl = trainControl(method = "repeatedcv",
                           number = 10,
                           repeats = 10,
                           classProbs = TRUE,
                           summaryFunction = twoClassSummary)

set.seed(123)
model.tree= train(formula,
                 data = train,
                 method = "rpart",
                 trControl = mFitControl,
                 preProcess = c("scale", "center"), 
                 cp = 0.001,  # parâmetro de complexidade
                 maxdepth = 30,
                 metric = "ROC")

Adaboost

model.ada = train(formula,
                  data = train,
                  trControl = trainControl(method = 'cv', number = 5),
                  preProcess = c("scale", "center"),   
                  method = "adaboost")

KNN

print_metrics(model.knn, train)

print_metrics(model.knn, validation_set)

Regressão Logística

print_metrics(model.logistic, train)

print_metrics(model.logistic, validation_set)

Ávore de Decisão

print_metrics(model.tree, train)

print_metrics(model.tree, validation_set)

Adaboost

print_metrics(model.ada, validation_set)

print_metrics(model.ada, train)

KNN

varImp(model.knn)

## ROC curve variable importance
## 
##                              Importance
## quantidade_fornecedores          100.00
## quantidade_despesas               99.76
## quantidade_doadores               94.41
## media_receita                     90.00
## media_despesa                     66.44
## recursos_proprios                 54.27
## recursos_de_partido_politico      29.08
## ocupacao                          18.26
## partido                            0.00

Regressão Logística

varImp(model.logistic, scale=FALSE)

## glm variable importance
## 
##                              Overall
## quantidade_doadores          15.5382
## media_receita                 9.0414
## media_despesa                 7.1620
## ocupacao                      7.0316
## recursos_proprios             5.7392
## quantidade_fornecedores       4.5098
## partido                       3.2009
## quantidade_despesas           2.2360
## recursos_de_partido_politico  0.9838

Aqui é notável o fato das features terem tido pouca importância para a classificação. Para esse modelo, portanto, poderíamos ter criado novas features baseada nas já existente e investigar se houve melhora nas métricas do modelo (lembrando que este modelo teve uma das piores performances, de acordo com nossas méticas da secção anterior).

Árvore de Decisão

varImp(model.tree)

## rpart variable importance
## 
##                              Overall
## quantidade_fornecedores       100.00
## quantidade_despesas            99.22
## media_receita                  82.10
## quantidade_doadores            79.51
## recursos_de_partido_politico   54.13
## ocupacao                       16.50
## media_despesa                  12.45
## partido                         0.00
## recursos_proprios               0.00

Adaboost

varImp(model.ada)

## ROC curve variable importance
## 
##                              Importance
## quantidade_fornecedores          100.00
## quantidade_despesas               99.76
## quantidade_doadores               94.41
## media_receita                     90.00
## media_despesa                     66.44
## recursos_proprios                 54.27
## recursos_de_partido_politico      29.08
## ocupacao                          18.26
## partido                            0.00

Random Forest

Para tentar melhorar os resultados, decidi utilizar Random forest, um método bastante utilizado e popular em desafios e na literatura. Neste método, vários modelos diferentes são criado, sendo todos eles porém simples. A ideia é unir diversos classificadores simples para construir uma boa árvore de decisão.

library(randomForest)

## randomForest 4.6-14

## Type rfNews() to see new features/changes/bug fixes.

## 
## Attaching package: 'randomForest'

## The following object is masked from 'package:ggplot2':
## 
##     margin

## The following object is masked from 'package:dplyr':
## 
##     combine

model.random.forest = randomForest(formula,
                                   data=train,
                                   importance=TRUE,
                                   ntree=2000)

print_metrics(model.random.forest, validation_set)

print_metrics(model.random.forest, train)

model.random.forest

## 
## Call:
##  randomForest(formula = formula, data = train, importance = TRUE,      ntree = 2000) 
##                Type of random forest: classification
##                      Number of trees: 2000
## No. of variables tried at each split: 3
## 
##         OOB estimate of  error rate: 8.56%
## Confusion matrix:
##            eleito nao_eleito class.error
## eleito        525        287  0.35344828
## nao_eleito    237       5071  0.04464959