Predição de Deputados Eleitos 2014

Classificação para prever quais candidatos à Câmara de Deputados serão eleitos nas eleições de 2014.

# Set-up
library(ggplot2)
library(caret)
library(tidyr)
library(dplyr)
library(dummies)

setwd("C:/Users/dimit/Desktop/Projetos/AD2")
train <- read.csv("data/train5.csv", encoding="UTF-8")
test <- read.csv("data/test5.csv", encoding="UTF-8")

Para o modelo inicial optei por não usar todas as variáveis (por motivos de otimização e paras implificar os modelos), algumas variáveis foram bem simples de remover, como por exemplo ID, nome e numero_cadidato, nesse caso é fácil de perceber que elas não deveriam impactar no modelo, algumas como setor_economico_receita e setor_economico_despesa, foram removidas por possuir muitos valores faltantes, técnicas de substituir artificialmente esses dados poderiam enviesar o modelo e por fim as variáveis UF, estado_civil e descricao_ocupacao merecem um pouco mais de cuidado, mas em teoria UF não deveria impactar já que os candidatos de mesmo UF “competem” entre si, estado_civil supostamente também não deveria impactar e finalmente descricao_ocupacao tem uma grande variação de valores categóricos o que pode deixar alguns valores mal representados e outros com muita representação.

# variáveis envolvidas no modelo 
# "situacao_final" (eleito ou não eleito)
train_dadosFiltrados <- train %>% select(partido, quantidade_doacoes, quantidade_doadores, total_receita, media_receita, recursos_de_outros_candidatos.comites, recursos_de_partidos, recursos_de_pessoas_físicas, recursos_de_pessoas_juridicas, recursos_proprios, quantidade_despesas, quantidade_fornecedores, total_despesa, media_despesa, idade, sexo, grau, descricao_cor_raca, despesa_max_campanha, situacao_final)
test_dadosFiltrados <- test %>% select(partido, quantidade_doacoes, quantidade_doadores, total_receita, media_receita, recursos_de_outros_candidatos.comites, recursos_de_partidos, recursos_de_pessoas_físicas, recursos_de_pessoas_juridicas, recursos_proprios, quantidade_despesas, quantidade_fornecedores, total_despesa, media_despesa, idade, sexo, grau, descricao_cor_raca, despesa_max_campanha)
formula = as.formula(situacao_final ~ partido + quantidade_doacoes + quantidade_doadores + total_receita + media_receita + recursos_de_outros_candidatos.comites + recursos_de_partidos + recursos_de_pessoas_físicas + recursos_de_pessoas_juridicas + recursos_proprios + quantidade_despesas + quantidade_fornecedores + total_despesa + media_despesa + idade + sexo + grau + descricao_cor_raca + despesa_max_campanha + situacao_final)

Para esse experimento iremo separar os dados de treinamento em treino e partição, na proporção de 75% e 25% respectivamente.

# Separa os dados em treino e validação
dataPartition <- createDataPartition(y = train_dadosFiltrados$situacao_final, p=0.75, list=FALSE)
treino <- train_dadosFiltrados[ dataPartition, ]
validacao <- train_dadosFiltrados[ -dataPartition, ]

1. Há desbalanceamento das classes (isto é, uma classe tem muito mais instâncias que outra)? Em que proporção? Quais efeitos colaterais o desbalanceamento de classes pode causar no classificador?

total = nrow(train)
dist_classes <- train %>% count(situacao_final)
ggplot(dist_classes, aes(y = dist_classes$n/total * 100, x = dist_classes$situacao_final))+
  geom_bar(stat="identity") +
  labs(title = "Distribuição de classes", x = "Situação final", y = "Proporção (%)") +
  theme(axis.text.x = element_text(angle = 0, hjust = 1), legend.position="none") +
  theme(axis.text=element_text(size=8), axis.title=element_text(size=12,face="bold"))

Como podemos observar na imagem, existe um grande desbalanceamento nas classes, mais de 80% dos dados são referentes a candidatos que não foram eleitos, isso faz bastante sentido já que apenas uma quantidade específica foi eleita, e normalmente é bem menor que o total de candidatos, mas para treinar um modelo isso acaba sendo ruim já que a classe dos não eleitos tem uma representação muito maior que a outra, isso pode enviesar o modelo para esses casos, ou seja, o modelo pode representar bem melhor esses dados que possuem mais exemplos (overfitting), e não representar tão bem a outra classe, já que existem poucos exemplos da mesma. Outro problema de dados desbalanceados é que nesse caso se o modelo prever todos os exemplos como “nao_eleitos” ainda sim ele conseguirá algo próximo de 80% de acurácia, e obviamente essa predição foi muito ruim, mas analisando apenas acurácia fica difícil de identificar isso.

2. Treine: um modelo de regressão logística, uma árvore de decisão e um modelo de adaboost. Tune esses modelos usando validação cruzada e controle overfitting se necessário, considerando as particularidades de cada modelo.

Para esses modelos iniciais iremos utilizar validação cruzada (5 k-fold) e uma busca aleatória por hiperparâmetros.

#Definição dos parâmetros.
# K-fold cross-validation
fitControl <- trainControl(method = "cv",
                    number = 5,
                    search= "random")

Regressão logística

model_glm <- train(formula,
                 data = treino,
                 method="glm",
                 trControl = fitControl,
                 family="binomial",
                 na.action = na.omit)

Árvore de decisão

model_rpart <- train(formula,
                 data=treino,
                 method = "rpart",
                 trControl = fitControl,
                 cp=0.001,
                 maxdepth=25)

Adaboost

model_adaboost <- train(formula,
                data=treino,
                trControl = fitControl,
                method = "adaboost")

3. Reporte acurácia, precision, recall e f-measure no treino e validação. Como você avalia os resultados? Justifique sua resposta.

Algumas métricas conhecidas para avaliarmos a eficácia de um modelo são:

-Accuracy (acurácia) -Precision -Recall -F-measure

Essas métricas são definidas em termos de Verdadeiros Positivos (TP), Verdadeiros Negativos (TN) Falsos Positivos (FP) e Falsos Negativos (FN).

Acurácia = (TP + TN)/(TP + TN + FP + FN) Nos diz a proporção de observações corretamente classificadas.

Precision = TP / (TP + FP) Diz respeito a quantas das observações preditas como positivas são realmente positivas

Recall = TP / (TP + FN) Diz respeito a quantas das observações positivas foram corretamente classificadas

F-measure = 2 * (Precision * Recall) / (Precision + Recall) Representa um valor que relaciona tanto precision quanto recall, ou seja caso você queira apenas um valor para avaliar o modelo, F-measure seria mais indicado do que usar precision ou recall sozinhos.

Aplicando essas medidas ao nosso contexto teríamos a seguinte leitura: -Accuracy: Proporção de políticos que foram corretamente classificados seja eleito ou não eleito. -Precision: Proporção dos políticos que foram classificados como eleito e realmente foram eleitos. -Recall: Proporção dos políticos eleitos que foram classificados como eleito.

validacao$predicaoGlm <- predict(model_glm, validacao)
validacao$predicaoRpart <- predict(model_rpart, validacao)
validacao$predicaoAdaboost <- predict(model_adaboost, validacao)
treino$predicaoGlm <- predict(model_glm, treino)
treino$predicaoRpart <- predict(model_rpart, treino)
treino$predicaoAdaboost <- predict(model_adaboost, treino)
TPGlmTrain <- treino %>% filter(situacao_final == "eleito", predicaoGlm == "eleito") %>% nrow()
TNGlmTrain <- treino %>% filter(situacao_final == "nao_eleito" , predicaoGlm == "nao_eleito" ) %>% nrow()
FPGlmTrain <- treino %>% filter(situacao_final == "nao_eleito" , predicaoGlm == "eleito") %>% nrow()
FNGlmTrain <- treino %>% filter(situacao_final == "eleito", predicaoGlm == "nao_eleito" ) %>% nrow()
TPRpartTrain <- treino %>% filter(situacao_final == "eleito", predicaoRpart == "eleito") %>% nrow()
TNRpartTrain <- treino %>% filter(situacao_final == "nao_eleito" , predicaoRpart == "nao_eleito" ) %>% nrow()
FPRpartTrain <- treino %>% filter(situacao_final == "nao_eleito" , predicaoRpart == "eleito") %>% nrow() 
FNRpartTrain <- treino %>% filter(situacao_final == "eleito", predicaoRpart == "nao_eleito" ) %>% nrow()
TPAdaboostTrain <- treino %>% filter(situacao_final == "eleito", predicaoAdaboost == "eleito") %>% nrow()
TNAdaboostTrain <- treino %>% filter(situacao_final == "nao_eleito" , predicaoAdaboost == "nao_eleito" ) %>% nrow()
FPAdaboostTrain <- treino %>% filter(situacao_final == "nao_eleito" , predicaoAdaboost == "eleito") %>% nrow() 
FNAdaboostTrain <- treino %>% filter(situacao_final == "eleito", predicaoAdaboost == "nao_eleito" ) %>% nrow()
TPGlmValidation <- validacao %>% filter(situacao_final == "eleito", predicaoGlm == "eleito") %>% nrow()
TNGlmValidation <- validacao %>% filter(situacao_final == "nao_eleito" , predicaoGlm == "nao_eleito" ) %>% nrow()
FPGlmValidation <- validacao %>% filter(situacao_final == "nao_eleito" , predicaoGlm == "eleito") %>% nrow()
FNGlmValidation <- validacao %>% filter(situacao_final == "eleito", predicaoGlm == "nao_eleito" ) %>% nrow()
TPRpartValidation <- validacao %>% filter(situacao_final == "eleito", predicaoRpart == "eleito") %>% nrow()
TNRpartValidation <- validacao %>% filter(situacao_final == "nao_eleito" , predicaoRpart == "nao_eleito" ) %>% nrow()
FPRpartValidation <- validacao %>% filter(situacao_final == "nao_eleito" , predicaoRpart == "eleito") %>% nrow() 
FNRpartValidation <- validacao %>% filter(situacao_final == "eleito", predicaoRpart == "nao_eleito" ) %>% nrow()
TPAdaboostValidation <- validacao %>% filter(situacao_final == "eleito", predicaoAdaboost == "eleito") %>% nrow()
TNAdaboostValidation <- validacao %>% filter(situacao_final == "nao_eleito" , predicaoAdaboost == "nao_eleito" ) %>% nrow()
FPAdaboostValidation <- validacao %>% filter(situacao_final == "nao_eleito" , predicaoAdaboost == "eleito") %>% nrow() 
FNAdaboostValidation <- validacao %>% filter(situacao_final == "eleito", predicaoAdaboost == "nao_eleito" ) %>% nrow()
accuracyGlmTrain <- (TPGlmTrain + TNGlmTrain)/(TPGlmTrain + TNGlmTrain + FPGlmTrain + FNGlmTrain) * 100
precisionGlmTrain <- TPGlmTrain / (TPGlmTrain + FPGlmTrain) * 100
recallGlmTrain <- TPGlmTrain / (TPGlmTrain + FNGlmTrain) * 100
fMeasureGlmTrain <- 2 * (precisionGlmTrain * recallGlmTrain) / (precisionGlmTrain + recallGlmTrain)
accuracyRpartTrain <- (TPRpartTrain + TNRpartTrain)/(TPRpartTrain + TNRpartTrain + FPRpartTrain + FNRpartTrain)  * 100
precisionRpartTrain <- TPRpartTrain / (TPRpartTrain + FPRpartTrain) * 100
recallRpartTrain <- TPRpartTrain / (TPRpartTrain + FNRpartTrain) * 100
fMeasureRpartTrain <- 2 * (precisionRpartTrain * recallRpartTrain) / (precisionRpartTrain + recallRpartTrain)
accuracyAdaboostTrain <- (TPAdaboostTrain + TNAdaboostTrain)/(TPAdaboostTrain + TNAdaboostTrain + FPAdaboostTrain + FNAdaboostTrain)  * 100
precisionAdaboostTrain <- TPAdaboostTrain / (TPAdaboostTrain + FPAdaboostTrain) * 100
recallAdaboostTrain <- TPAdaboostTrain / (TPAdaboostTrain + FNAdaboostTrain) * 100
fMeasureAdaboostTrain <- 2 * (precisionAdaboostTrain * recallAdaboostTrain) / (precisionAdaboostTrain + recallAdaboostTrain)
accuracyGlmValidation <- (TPGlmValidation + TNGlmValidation)/(TPGlmValidation + TNGlmValidation + FPGlmValidation + FNGlmValidation) * 100
precisionGlmValidation <- TPGlmValidation / (TPGlmValidation + FPGlmValidation) * 100
recallGlmValidation <- TPGlmValidation / (TPGlmValidation + FNGlmValidation) * 100
fMeasureGlmValidation <- 2 * (precisionGlmValidation * recallGlmValidation) / (precisionGlmValidation + recallGlmValidation)
accuracyRpartValidation <- (TPRpartValidation + TNRpartValidation)/(TPRpartValidation + TNRpartValidation + FPRpartValidation + FNRpartValidation)  * 100
precisionRpartValidation <- TPRpartValidation / (TPRpartValidation + FPRpartValidation) * 100
recallRpartValidation <- TPRpartValidation / (TPRpartValidation + FNRpartValidation) * 100
fMeasureRpartValidation <- 2 * (precisionRpartValidation * recallRpartValidation) / (precisionRpartValidation + recallRpartValidation)
accuracyAdaboostValidation <- (TPAdaboostValidation + TNAdaboostValidation)/(TPAdaboostValidation + TNAdaboostValidation + FPAdaboostValidation + FNAdaboostValidation)  * 100
precisionAdaboostValidation <- TPAdaboostValidation / (TPAdaboostValidation + FPAdaboostValidation) * 100
recallAdaboostValidation <- TPAdaboostValidation / (TPAdaboostValidation + FNAdaboostValidation) * 100
fMeasureAdaboostValidation <- 2 * (precisionAdaboostValidation * recallAdaboostValidation) / (precisionAdaboostValidation + recallAdaboostValidation)
print('Treino')

[1] "Treino"

print('Regressão logística')

[1] "Regressão logística"

sprintf(" -acurácia: %.2f%%", accuracyGlmTrain)

[1] " -acurácia: 93.52%"

sprintf(" -precisão: %.2f%%", precisionGlmTrain)

[1] " -precisão: 73.62%"

sprintf(" -recall: %.2f%%", recallGlmTrain)

[1] " -recall: 55.45%"

sprintf(" -f-measure: %.2f%%", fMeasureGlmTrain)

[1] " -f-measure: 63.25%"

print('Árvore de decisão')

[1] "Árvore de decisão"

sprintf(" -acurácia: %.2f%%", accuracyRpartTrain)

[1] " -acurácia: 95.52%"

sprintf(" -precisão: %.2f%%", precisionRpartTrain)

[1] " -precisão: 80.57%"

sprintf(" -recall: %.2f%%", recallRpartTrain)

[1] " -recall: 73.08%"

sprintf(" -f-measure: %.2f%%", fMeasureRpartTrain)

[1] " -f-measure: 76.64%"

print('Adaboost')

[1] "Adaboost"

sprintf(" -acurácia: %.2f%%", accuracyAdaboostTrain)

[1] " -acurácia: 98.55%"

sprintf(" -precisão: %.2f%%", precisionAdaboostTrain)

[1] " -precisão: 93.20%"

sprintf(" -recall: %.2f%%", recallAdaboostTrain)

[1] " -recall: 92.31%"

sprintf(" -f-measure: %.2f%%", fMeasureAdaboostTrain)

[1] " -f-measure: 92.75%"

print('Validação')

[1] "Validação"

print('Regressão logística')

[1] "Regressão logística"

sprintf(" -acurácia: %.2f%%", accuracyGlmValidation)

[1] " -acurácia: 94.29%"

sprintf(" -precisão: %.2f%%", precisionGlmValidation)

[1] " -precisão: 80.82%"

sprintf(" -recall: %.2f%%", recallGlmValidation)

[1] " -recall: 56.73%"

sprintf(" -f-measure: %.2f%%", fMeasureGlmValidation)

[1] " -f-measure: 66.67%"

print('Árvore de decisão')

[1] "Árvore de decisão"

sprintf(" -acurácia: %.2f%%", accuracyRpartValidation)

[1] " -acurácia: 95.26%"

sprintf(" -precisão: %.2f%%", precisionRpartValidation)

[1] " -precisão: 80.90%"

sprintf(" -recall: %.2f%%", recallRpartValidation)

[1] " -recall: 69.23%"

sprintf(" -f-measure: %.2f%%", fMeasureRpartValidation)

[1] " -f-measure: 74.61%"

print('Adaboost')

[1] "Adaboost"

sprintf(" -acurácia: %.2f%%", accuracyAdaboostValidation)

[1] " -acurácia: 98.55%"

sprintf(" -precisão: %.2f%%", precisionAdaboostValidation)

[1] " -precisão: 95.88%"

sprintf(" -recall: %.2f%%", recallAdaboostValidation)

[1] " -recall: 89.42%"

sprintf(" -f-measure: %.2f%%", fMeasureAdaboostValidation)

[1] " -f-measure: 92.54%"

Avaliando os resultado do treino na questão 2 e a validação mostrada acima, com base na descrição dos atributos, primeiramente podemos avaliar se houve ou não overfitting, para o modelo glm tivemos 93.52% e 94.29% de acurácia, para rpart tivemos 95.52% e 95.26% de acurácia e para adaboost 98.55% e 98.55% de acurácia no treino e validação respectivamente.

No caso da regressão logística e do modelo Rpart como os valores estão muito próximos isso é um índice que não houve overfitting, obviamente supondo que houve uma distribuição e variação interessante entre dados de treino e validação.

Para o modelo Adaboost não houve variância entre treino e validação, além disso o resultado foi muito bom, sendo assim o modelo usando adaboot se mostrou o melhor nesse experimento inicial.

4. Interprete as saídas dos modelos. Quais atributos parecem ser mais importantes de acordo com cada modelo? Crie pelo menos um novo atributo que não está nos dados originais e estude o impacto desse atributo.

# Regressão logística
ggplot(varImp(model_glm))

# Rpart
ggplot(varImp(model_rpart))

# Adaboost
ggplot(varImp(model_adaboost))

É bem interessante notar que para cada modelo nós temos diferente importâncias entre as variáveis, inclusive a variável mais importante não foi a mesma para todos os modelos, isso enfatiza o fato de que possivelmente não existe uma manipulação de dados genérica que funciona bem para qualquer modelo, isso vai depender principalmente de qual modelo será usado.

Para o modelo de regressão logística temos o seguinte, as 3 mais importantes foram despesa_max_campanha, media_despesa e sexoMasculino, e as 3 menos importantes foram descricao_cor_racaIndigena, partidoPCO e “grauLÊ E Escreve”.

Para o modelo Rpart o resultado foi: as 3 mais importantes, total_receita, total_despesa, quantidade_doacoes e as 3 piores foram partidoPSDB, partidoPCO e partidoPMDB

Para o modelo Adaboost ficou o seguinte: 3 mais importantes foram total_receita, total_despesa e quantidade_despesas já as 3 piores foram partido, idade e sexo.

Com essa análise podemos observar mais algumas coisas interessantes, como por exemplo 8 das 9 variáveis mais importantes estão relacionadas com dinheiro investido na campanha o que faz bastante sentido, outro detalhe é que em todos os modelos partidos parecem ser irrelevantes de forma geral.

Para criar um novo atributo e medir sua eficiência iremos utilizar os modelos Rpart e regressão logística, pois eles se mostraram eficientes e possuem um tempo de treinamento bem rápido.

O novo atributo será “idadeBin”, que seria nada mais que o atributo idade alterado para que corresponda a um intervalo, que nesse caso seria [18, 38, 58, 78, 98, 200], usei esses dados para tentar representar a idade dos candidatos e intervalos de 20 anos dos mais jovens até os mais velhos, e assim tentar analisar se a faixa etária vista de uma forma agrupada faz mais sentido do que usar idades da forma convencional.

# novo atributo (idadeBin) (aplicando também aos dados de teste)
train$idadeBin <- cut(train$idade, breaks = c(18, 38, 58, 78, 98, 200), labels=FALSE)
test$idadeBin <- cut(test$idade, breaks = c(18, 38, 58, 78, 98, 200), labels=FALSE)
train_dadosFiltradosEngineered <- train %>% select(partido, quantidade_doacoes, quantidade_doadores, total_receita, media_receita, recursos_de_outros_candidatos.comites, recursos_de_partidos, recursos_de_pessoas_físicas, recursos_de_pessoas_juridicas, recursos_proprios, quantidade_despesas, quantidade_fornecedores, total_despesa, media_despesa, idade, sexo, grau, descricao_cor_raca, despesa_max_campanha, situacao_final, idadeBin)
# variáveis envolvidas no modelo
formulaEngineered = as.formula(situacao_final ~ partido + quantidade_doacoes + quantidade_doadores + total_receita + media_receita + recursos_de_outros_candidatos.comites + recursos_de_partidos + recursos_de_pessoas_físicas + recursos_de_pessoas_juridicas + recursos_proprios + quantidade_despesas + quantidade_fornecedores + total_despesa + media_despesa + idade + sexo + grau + descricao_cor_raca + despesa_max_campanha + situacao_final + idadeBin)
# partição
dataPartitionEngineered <- createDataPartition(y = train_dadosFiltradosEngineered$situacao_final, p=0.75, list=FALSE)
treinoEngineered <- train_dadosFiltradosEngineered[ dataPartitionEngineered, ]
validacaoEngineered <- train_dadosFiltradosEngineered[ -dataPartitionEngineered, ]

# Rpart
model_rpart2 <- train(formulaEngineered,
                 data=treinoEngineered,
                 method = "rpart",
                 trControl = fitControl,
                 cp=0.001,
                 maxdepth=25)

# Regressão logística
model_glm2 <- train(formulaEngineered,
                 data = treinoEngineered,
                 method="glm",
                 trControl = fitControl,
                 family="binomial",
                 na.action = na.omit)

# importância das variáveis
ggplot(varImp(model_rpart2))

ggplot(varImp(model_glm2))

Nesses dois casos podemos observar justamente o que foi dito anteriormente, o novo atributo não ajudou em nada no modelo rpart, já para o modelo de regressão logística ele teve um impacto positivo, olhando pelo gráfico ele parece ser quase 3 vezes melhor que o anterior, ou seja a criação de novos atributos está ligado ao modelo na qual ele será usado.

5. Envie seus melhores modelos à competição do Kaggle. Sugestões para melhorar o modelo:

1. Experimente outros modelos (e.g. SVM, RandomForests e GradientBoosting)

2. Crie pelo menos um novo atributo (opcional).

Uma das formas mais simples de ajustar os atributos dos dados é substituindo os dados faltantes por algum valor que faça sentido no contexto do atributo, para isso iremos verificar quais atributos possuem valores faltantes.

# substituindo valores marcados como "#NULO" pra "NA", e valores numéricos marcados como 0 por "NA" (isso não irá ser aplicado em todas as colunas numéricas, alguma fazem sentido ter valores 0)
# obs o processamento deve ser feito para os dados de treino e teste
train[train == '#NULO'] <- NA
test[test == '#NULO'] <- NA
# observando a quantidade de valores nulos para cada atributo
sapply(train, function(y) sum(length(which(is.na(y)))))

                                   ID                                  nome                       numero_cadidato 
                                    0                                     0                                     0 
                                   UF                               partido               setor_economico_receita 
                                    0                                     0                                  2140 
                   quantidade_doacoes                   quantidade_doadores                         total_receita 
                                    0                                     0                                     0 
                        media_receita recursos_de_outros_candidatos.comites                  recursos_de_partidos 
                                    0                                     0                                     0 
          recursos_de_pessoas_físicas         recursos_de_pessoas_juridicas                     recursos_proprios 
                                    0                                     0                                     0 
                  quantidade_despesas               quantidade_fornecedores                         total_despesa 
                                    0                                     0                                     0 
                        media_despesa               setor_economico_despesa                                 idade 
                                    0                                  2310                                     0 
                                 sexo                                  grau                          estado_civil 
                                    0                                     0                                     0 
                   descricao_ocupacao                    descricao_cor_raca                  despesa_max_campanha 
                                    0                                     0                                     0 
                       situacao_final                              idadeBin 
                                    0                                     0 

Por coincidência os atributos que possuem valores nulos foram os que já haviam sido removidos, no caso dos dois é importante notar que existem mais atributos nulos que os demais, então seria difícil de inferir esses valores de forma eficiente sem que acabe atrapalhando o modelo.

Como foi observador na questão 1 existe um grande desbalanceamento no conjunto de dados, e isso provavelmente está prejudicando nosso modelo, então uma forma simples de melhorar seria balancear as classes (eleito e não eleito), as duas maneiras mais simples seriam usando oversampling (adicionar novos exemplos da classe menor) e undersampling (remover exemplos da classe maior)

# balanceado as classes
# K-fold cross-validation e uso de undersampling
fitControlUnder <- trainControl(method = "cv",
                    number = 10,
                    search= "random",
                    sampling = "down")
# K-fold cross-validation e uso de oversampling
fitControlOver <- trainControl(method = "cv",
                    number = 10,
                    search= "random",
                    sampling = "up")
fitControlRose <- trainControl(method = "cv",
                    number = 10,
                    search= "random",
                    sampling = "rose")
fitControlSmote <- trainControl(method = "cv",
                    number = 10,
                    search= "random",
                    sampling = "smote")

# removendo atributos não usados
trainUpdated <- train %>% select(partido, quantidade_doacoes, quantidade_doadores, total_receita, media_receita, recursos_de_outros_candidatos.comites, recursos_de_partidos, recursos_de_pessoas_físicas, recursos_de_pessoas_juridicas, recursos_proprios, quantidade_despesas, quantidade_fornecedores, total_despesa, media_despesa, idade, sexo, grau, descricao_cor_raca, despesa_max_campanha, situacao_final, idadeBin)
testUpdated <- test %>% select(partido, quantidade_doacoes, quantidade_doadores, total_receita, media_receita, recursos_de_outros_candidatos.comites, recursos_de_partidos, recursos_de_pessoas_físicas, recursos_de_pessoas_juridicas, recursos_proprios, quantidade_despesas, quantidade_fornecedores, total_despesa, media_despesa, idade, sexo, grau, descricao_cor_raca, despesa_max_campanha, idadeBin)
# transformando os valores categóricos para o formato one hot
trainUpdated <- dummy.data.frame(trainUpdated, names=c('estado_civil'), sep="_")
trainUpdated <- dummy.data.frame(trainUpdated, names=c('sexo'), sep="_")
trainUpdated <- dummy.data.frame(trainUpdated, names=c('grau'), sep="_")
trainUpdated <- dummy.data.frame(trainUpdated, names=c('descricao_cor_raca'), sep="_")
testUpdated <- dummy.data.frame(testUpdated, names=c('estado_civil'), sep="_")
testUpdated <- dummy.data.frame(testUpdated, names=c('sexo'), sep="_")
testUpdated <- dummy.data.frame(testUpdated, names=c('grau'), sep="_")
testUpdated <- dummy.data.frame(testUpdated, names=c('descricao_cor_raca'), sep="_")
# variáveis envolvidas no modelo
formulaEngineered = as.formula(situacao_final ~ partido + quantidade_doacoes + quantidade_doadores + total_receita + media_receita + recursos_de_outros_candidatos.comites + recursos_de_partidos + recursos_de_pessoas_físicas + recursos_de_pessoas_juridicas + recursos_proprios + quantidade_despesas + quantidade_fornecedores + total_despesa + media_despesa + idade + sexo + grau + descricao_cor_raca + despesa_max_campanha + situacao_final + idadeBin)
# partição
dataPartitionEngineered <- createDataPartition(y = trainUpdated$situacao_final, p=0.80, list=FALSE)
treinoEngineered <- trainUpdated[ dataPartitionEngineered, ]
validacaoEngineered <- trainUpdated[ -dataPartitionEngineered, ]

# modelos balanceados com os novos dados
model <- train(situacao_final ~ .,
                 data=treinoEngineered,
                 method = "adaboost",
                 preProcess = c("scale", "center"),
                 trControl = fitControlUnder)

Link com os dados: https://www.kaggle.com/c/ufcg-ad2-20172-lab3