Simulando o treinamento do modelo para modelos ML robustos

Nesta postagem, explicarei por que as simulações devem ser executadas no processo de treinamento de modelos para que os modelos não falhem na produção. Tradicionalmente, estamos sempre acostumados a treinar modelos em determinadas proporções de divisão, por exemplo, 70:30 ou 80:20. A questão fundamental é que nem sempre treinamos modelos em diferentes partes dos dados nessas divisões, como mostra a imagem abaixo.

Portanto, torna-se vital garantir que o modelo seja treinado em vários cenários para garantir que o modelo não seja tendencioso. Isso também garante que o modelo seja confiável e robusto o suficiente para implementá-lo na produção.

Abaixo, veremos um exemplo de como tudo isso acontece. Os passos são os seguintes:

1. carregar bibliotecas
2. carregar o conjunto de dados mtcars
3. escreva uma função para dividir dados em diferentes graus
4. executar simulação em um loop para obter taxas de erro
5. Finalmente visualizando o resultado

Começaremos com o carregamento de bibliotecas e nosso conjunto de dados, como mostrado abaixo

# load libraries
library(MASS)
library(e1071)
library(Metrics)
library(dplyr)

# load data
data(mtcars)

A seguir, escreveremos uma função que inclui

• defina o valor inicial. Isso ocorre porque queremos capturar novos dados todas as vezes (duh! Esse é o objetivo dessa simulação)
• dividir os dados para treinar e testar em várias proporções
• construir um modelo SVM usando dados de trem
• faça previsões em dados de teste
• calcular e retornar o valor do erro (MAE)

# function to run simulation
runsimulation = function(i, split){

  seedValue = i*rnorm(1)

  # change seed values
  set.seed(seedValue)

  # create samples
  samples = sample(1:nrow(mtcars), split*nrow(mtcars))

  # split data to test and train
  train = mtcars[samples, ]
  test = mtcars[-samples, ]

  # build a model
  model = svm(mpg ~ ., data  = train, scale = F, kernel = "radial")

  # do predictions
  prediction = predict(model, test %>% select(-mpg))

  # calculate error
  error = mae(actual = test$mpg, predicted = prediction)

  # return error values
  return(error)

}

Criaremos uma sequência de taxas de divisão e, em seguida, executaremos essas taxas no loop. Para cada taxa de divisão, executaremos cerca de 300 execuções.

# create split ratios
split = seq(from = 0.5, to = 0.95, by = 0.05) %>% rep(300) %>% sort(decreasing = FALSE)

# get the length of i for seed values
i = 1:length(split)

# get errors
errors = mapply(runsimulation, i = i, split = split)

# put data into a data frame
simResults = data.frame(split, errors)

Por fim, visualizamos os dados e analisamos os resultados. No gráfico da caixa abaixo, podemos ver que a mediana diminui à medida que a taxa de divisão aumenta. Isso deve ser verdade, pois estamos alimentando mais dados para o modelo. Também observamos que o erro mínimo diminui à medida que adicionamos mais dados durante o treinamento. Isso também aumenta os erros máximos. Também podemos observar observações semelhantes para quantil.

A seguir, veremos o resumo da média e variância para cada proporção de divisão. Percebemos que o menor erro médio ocorre com 95% de divisão e também com maior grau de SD. e vice versa.

# plot results
boxplot(errors~split,
data = simResults,
main = "Error Simulation Results",
xlab = "Train Split",
ylab = "Mean Absolute Error",
col = "light blue")
grid (NULL,NULL, lty = 6, col = "cornsilk2") 

simResults %>%
  group_by(split) %>%
  summarise(mean = mean(errors), sd = sd(errors)) %>%
  data.frame
#     split   mean      sd
# 1   0.50 4.826838 0.7090876
# 2   0.55 4.701303 0.8178482
# 3   0.60 4.674690 0.8442144
# 4   0.65 4.645363 0.8727532
# 5   0.70 4.652534 1.0769249
# 6   0.75 4.555186 1.1046217
# 7   0.80 4.588761 1.3002216
# 8   0.85 4.572775 1.6021275
# 9   0.90 4.519118 1.7865828
# 10  0.95 4.443357 2.4188333

Neste ponto, cabe ao tomador de decisão decidir qual modelo deve ser adotado. Eles podem oferecer variações significativas nas taxas de erro ou desejam controlar a variação da taxa de erro. Se eu fosse o tomador de decisão, eu dividiria 65% ou 70% e controlaria essa variação por erro.

Em conclusão, o aprendizado de máquina é difícil. Não é tão simples quanto ajustar um modelo com dados. Você precisa executar simulações como acima para analisar seus modelos. O exemplo acima é o caso mais simples que você pode encontrar. Quando você chega a hiper parâmetros, fica ainda mais complicado. Não há um conjunto de ferramentas ou fluxos que funcione para todos. Às vezes, você precisa ser criativo e criar seus próprios fluxos.

Espero que você tenha gostado deste tutorial rápido. Sinta-se livre para curtir, compartilhar e se inscrever neste blog.

Relacionado