Este é o segundo artigo sobre os modelos clássicos de machine learning tradicional. No primeiro artigo, apresentamos os vizinhos mais próximos. Na parte 2, abordaremos as árvores de decisão.
Árvores de decisão
Árvores de decisão são determinísticas; após construídas, não mudam. Os algoritmos tradicionais de árvore de decisão retornam a mesma árvore de decisão para o mesmo conjunto de treinamento. Mas se a árvore não funciona muito bem, podemos fazer algo? Sim! Podemos criar uma floresta de árvores.
Ao criar uma floresta de árvores, adicionamos aleatoriedade, de forma a gerar uma floresta de árvores únicas, cada uma com as próprias potencialidades e fragilidades, mas que, coletivamente, são melhores do que qualquer árvore isolada. Uma floresta aleatória é uma coleção de árvores de decisão, e cada uma delas é aleatoriamente diferente das outras.
Três etapas são necessárias para criar uma floresta aleatória: bagging (também chamado de bootstrapping), seleção aleatória de features e ensemble. O bagging e a seleção aleatória de features ajudam a prevenir o sobreajuste. Uma única árvore de decisão está propensa a sobreajuste.
A explicabilidade é o preço pago por esse melhor desempenho. Uma única árvore de decisão se explica pela série de perguntas e de respostas que geram sua saída. Como dezenas ou centenas de árvores de decisão combinam suas saídas, a explicabilidade se perde, mas, em muitos casos, isso é aceitável.
Bagging (Bootstrap Aggregating)
À medida que desenvolvemos a floresta, árvore por árvore, usamos o conjunto existente de treinamento para criar conjuntos de treinamento específicos para a árvore de decisão atual. É nesse momento que o bagging entra em cena.
Bagging se refere à criação de um conjunto novo de dados a partir do conjunto atual, por amostragem aleatória com substituição. Nesta técnica, podemos selecionar uma amostra de treinamento mais de uma vez. Considere o conjunto de dados de exemplo de scores de teste para apresentar o conceito.
95, 88, 76, 81, 92, 70, 86, 87, 72
No teste, uma das formas de avaliar o desempenho de uma classe é calcular o score médio. Divide-se a soma de todos os scores pelo número de scores. Como a soma é 747, e temos 9 scores, alcançamos a média de 83.
Coletivamente, os scores dos testes são uma amostra de um processo pai hipotético que gera scores para o teste específico realizado. Os scores de teste de outro grupo representam outra amostra do processo pai para esse teste. Se tivermos scores de testes de muitas classes, podemos ter uma ideia sobre o verdadeiro score médio de teste, ou pelo menos, sobre o intervalo no qual esperamos encontrar o score médio.
Usaremos o bagging para criar conjuntos novos de dados a partir da coleção de scores de testes que temos e analisaremos suas médias. Escolhemos aleatoriamente valores da coleção de scores de testes, sem nos preocuparmos se já repetimos algum score específico. Vejamos seis desses conjuntos de dados amostrados aleatoriamente por substituição (bootstrap):
86, 87, 87, 76, 81, 81, 88, 70, 95 (Soma = 751, Média = 83,4)
87, 92, 76, 87, 87, 76, 87, 92, 92 (Soma = 776, Média = 86,2)
95, 70, 87, 92, 70, 92, 72, 70, 72 (Soma = 720, Média = 80)
88, 86, 87, 70, 81, 72, 86, 95, 70 (Soma = 735, Média = 81,7)
86, 86, 92, 86, 87, 86, 70, 81, 87 (Soma = 761, Média = 84,6)
76, 88, 88, 88, 88, 72, 86, 95, 70 (Soma = 751, Média = 83,4)
A menor média é de 80.0% e a maior é de 86.2%. Com isso, podemos até acreditar que um grande número de amostras gerará uma média mais ou menos nesse intervalo.
É assim que um estatístico pode usar o bagging. Para nós, a parte crítica são os seis novos conjuntos de dados extraídos do conjunto original de dados. Ao desenvolver uma floresta aleatória, sempre que precisarmos de uma árvore nova de decisão, primeiro usaremos o bagging para gerar um conjunto novo de dados e, em seguida, treinaremos a árvore de decisão usando esse conjunto de dados, não o original.
Seleção aleatória de features
O segundo mecanismo que uma floresta aleatória usa é treinar a árvore de decisão em um conjunto de features aleatoriamente selecionado. Usaremos o conjunto ilustrativo de dados da tabela abaixo para entender o que isso significa.
| # | x₀ | x₁ | x₂ | x₃ | x₄ | x₅ |
|---|---|---|---|---|---|---|
| 1 | 0.52 | 0.95 | 0.81 | 0.78 | 0.97 | 0.36 |
| 2 | 0.89 | 0.37 | 0.66 | 0.55 | 0.75 | 0.45 |
| 3 | 0.49 | 0.98 | 0.49 | 0.39 | 0.42 | 0.24 |
| 4 | 0.43 | 0.51 | 0.90 | 0.78 | 0.19 | 0.22 |
| 5 | 0.51 | 0.16 | 0.11 | 0.48 | 0.34 | 0.54 |
| 6 | 0.48 | 0.99 | 0.62 | 0.58 | 0.72 | 0.42 |
| 7 | 0.80 | 0.84 | 0.72 | 0.26 | 0.93 | 0.23 |
| 8 | 0.50 | 0.70 | 0.13 | 0.35 | 0.96 | 0.82 |
| 9 | 0.70 | 0.54 | 0.62 | 0.72 | 0.14 | 0.53 |
Esse conjunto ilustrativo de dados é formado com nove vetores de feature, cada um com seis features, de x0 a x5. As árvores de decisão da floresta usam um subconjunto selecionado aleatoriamente destas seis features. Por exemplo, digamos que mantemos aleatoriamente as features x0, x4 e x5. A Tabela abaixo mostra o conjunto de dados usado para treinar a árvore de decisão.
| # | x₀ | x₄ | x₅ |
|---|---|---|---|
| 1 | 0.52 | 0.97 | 0.36 |
| 2 | 0.89 | 0.75 | 0.45 |
| 3 | 0.49 | 0.42 | 0.24 |
| 4 | 0.43 | 0.19 | 0.22 |
| 5 | 0.51 | 0.34 | 0.54 |
| 6 | 0.48 | 0.72 | 0.42 |
| 7 | 0.80 | 0.93 | 0.23 |
| 8 | 0.50 | 0.96 | 0.82 |
| 9 | 0.70 | 0.14 | 0.53 |
Na floresta, cada árvore de decisão será treinada com uma versão de amostras selecionada aleatoriamente por substituição a partir do conjunto de dados, e usará apenas um subconjunto das features disponíveis. A aleatoriedade é aplicada duas vezes para tornar as árvores diferentes entre si: primeiro com os dados de treinamento, depois com as features que considerarão.
Ensemble
Agora que temos uma floresta, como usá-la? Com a última etapa: ensemble. Uma floresta aleatória gera uma única saída, um rótulo de classe, combinando os rótulos gerados por árvores de decisão, votando como um classificador k-vizinhos mais próximos.
Por exemplo, se quisermos usar a floresta aleatória para classificar a amostra X, e existir 100 árvores na floresta aleatória (já treinadas), fornecemos a cada árvore a amostra X. As árvores sabem quais subconjuntos de features da amostra X usar para chegar em uma folha com um rótulo. Agora, temos 100 rótulos possíveis de classe, a saída das 100 árvores de decisão da floresta. Se 78 das árvores atribuírem a amostra X à classe Y, a floresta aleatória declara a amostra X como uma instância da classe Y.
Referências
Kneusel, Ronald T.. Como a Inteligência Artificial Funciona: Da Magia à Ciência
Comments (0)