Aprendendo Machine Learning (Parte 1: DecisionTreeRegressor e RandomForestRegressor) | by Leitor de mapa, Data Science e Matemágica! | Jan, 2024

Como eu sempre digo, qual o próximo passo? Essa pergunta te impulsiona a sempre se manter no caminho para os seus objetivos, pois mais importante para onde se quer chegar é o caminho à trilhar.

Em Computação não é diferente, primeiramente deve-se falar o idioma mais usado no meio, que hoje em dia é o inglês. Precisa ser o inglês mais correto, com o uso correto do verbo to be e com toda a rebusquês do inglês britânico? Não. No começo, para fins de leitura, quase qualquer curso meia boca já serve, o necessário é ter um vocabulário mínimo e uma frase que é a minha mais nova frase favorita:

Então, com o inglês mínimo na bagagem agora é hora de aprender outro idioma, na verdade a linguagem que as máquinas utilizam, que deriva do inglês, mas com comandos e códigos que, não chega a ser um vocabulário novo e infinitamente vasto, mas quanto mais você souber o que está mandando a máquina fazer mais fácil pra você interpretar códigos de outras pessoas, usar soluções dos fóruns e de ajuda dos colegas, afinal com copia-e-cola vai te levar só a alguns metros de distância, a jornada é de milhares de quilômetros, então faça uma lista das ferramentas necessárias:

INGLÊS: OK, LINGUAGEM(Python, no meu caso): OK.

Agora vamos verdadeiramente ao próximo passo, que é Machine Learning, um ML diferente do Mercado Livre, ou Aprendizado de Máquina, vamos ensinar uma máquina modelos de análise de dados, treinar, refinar e validar esses modelos. Mas por onde começar?

Tem o google com suas milhares de web sites e respostas, onde achamos, por exemplo, o TechGuide da Alura, o Kaggle e no Youtube encontrei o Mario Filho, com suas playlists bem organizadas de Machine Learning e de desafios do Kaggle.

Então com esses hyperlinks chegou a hora de sentar, pegar uns litros de café, alguma coisa para comer e ler, assistir, escutar e estudar.

O Machine Learning consiste na criação de modelos, com o python, para pegar uma massa de dados, e ‘treinar’ o modelo. Mas o que são modelos?

Modelos são comandos de bibliotecas do Python, comecemos com o Pandas, que nos dá ferramentas para abrir-mos de fato os arquivos contendo os dados.

Esses arquivos são, em geral, exportação de grandes tabelas de excel ou comparable (as menores possuem pouco mais de mil linhas por 5 a ten colunas). Esses dados, apesar de tabulados em aplicativos como o excel, eles ultrapassam a capacidade do programa de lidar com todos esses dados e não possuem as ferramentas necessárias, enquanto que no excel essa massa de dados é uma planilha gigante, no pandas podemos usar funções internas como describe(), que nos mostra o entire de linhas, de colunas, média, mediana, quartis e alguns outros dados estatísticos simples.

O modelo de ML começa a tomar forma realmente quando usamos outra biblioteca, o scikit-learn(sklearn), em que podemos usar sua ferramenta de Árvore de Decisão (DecisionTreeRegressor), que nos dá um modelo de predição bom, mas simplório e a Floresta Randômica (RandomForestRegressor) que é uma ‘evolução’ da Árvore, melhorando o desempenho desses modelos.

Mas como esse modelo nos dá esses resultados? Pegamos a massa de dados, definimos qual coluna, ou dado, nos interessa, e usamos as outras colunas, ou parte delas como parâmetro para definirmos a primeira.

Exemplificando, em uma massa de dados, planilha do excel, temos os preços e características de casas. Dentre essas características temos, tamanho de área construída, número de quartos, banheiros e ano de construção.

Quem já procurou casa/apartamento pra alugar/comprar sabe como é.

O preço do imóvel é construído usando essas características como parâmetros, dentre outros claro, mas para se ter uma noção de valor de mercado esses são os mais usado.

Pois bem, nosso alvo é saber o preço de um imóvel, ou uma nova massa de dados de imóveis, os prováveis preços, baseados nos parâmetros: tamanho de área construída, número de quartos, banheiros e ano de construção. O preço será nosso alvo denominado de y, emblem nosso y=valorImóvel, enquanto que nosso X será os parâmetros, X=[‘tamanho de área construída’, ‘número de quartos’, ‘banheiros’ e ‘ano de construção’].

Nosso modelo será y em função de X, então precisaremos primeiro ‘treinar’ o modelo. Treinar significa, colocar os nossos parâmetros X para calibrar a previsão para y. É o mesmo processo psychological, com uso de ferramentas e calculadoras, que um corretor de imóveis faz, ele pega todos os dados, aplica um peso a cada um, o tamanho multiplicado pelo metro quadrado da região construída, mais o número de quartos e banheiros, menos sua depreciação em função do ano de construção, além claro de última reforma, instalação elétrica, hidráulica, garagem, e outros fatores, mas aqui estamos simplificando.

Falando em simplificar, depois de treinar o modelo, podemos usá-lo para definir os preços de outros imóveis, 1 a 1, ou pegar outra massa de dados de 10 mil, 100 mil ou 1 milhão de imóveis e num estalar de dedos, alguns estalares, teremos uma aproximação do valor dos imóveis, é pra isso que Machine Learning, na verdade Ciência de Dados serve, criar um modelo e aplicá-lo na vida precise, para facilitar o trabalho do ser humano, que demoraria dias, semanas ou até meses, pra chegar em dados semelhantes.

Mas falamos também de treinar o modelo e validar o modelo.

Então o modelo anterior ele está muito bem treinado, mas não validado, mas como validar ele se não temos dados novos, já que usamos todos os dados para treiná-lo. Tal qual um lutador de judô, ele treinou com todos os colegas que dojô, mas vai lutar contra outros dojôs, que não temos acesso ainda, podendo falhar miserávelmente no primeiro embate, pois ele sabe, ‘decorou’, os movimentos de todos os colegas, mas não lutou efetivamente contra nenhum, não foi VALIDADO.

Para isso vamos apagar o modelo anterior e usar uma outra ferramenta do sklearn, o train_test_split.

Mas antes vamos dar nomes aos elementos que já vimos, a nossa massa de dados vamos chamar de mDados, que vai ser o arquivo csv (dados.csv) já sendo manipulado pelo Pandas, então mDados = pd.read_csv(dados.csv).

O nosso objeto alvo, o y, será y = mDados.valorImóvel

O nosso X, ou nossos choices (do inglês características), será X=[‘tamanho de área construída’, ‘número de quartos’, ‘banheiros’ e ‘ano de construção’].

Enquanto o y deve ser um único alvo, o X pode ser muitos, quanto mais melhor.

Certo, agora vamos usar o comando:

train_X, val_X, train_y, val_y = train_test_split(X, y, random_state=1)

train_X: choices para treinar o modelo

val_X: choices para validar o modelo

train_y: dados da operate alvo para servir ao treino

val_y: dados da operate alvo para servir á validação.

O train_test_split pega a massa de dados com as choices X e os alvos y e as divide em 2 pacotes, 1 para treino e outro para validação. O random_state serve para poder repetir os mesmos treinos e mesmas validações, caso seja necessário atestar que os treinos e validações foram feitas de maneira correta, podendo assumir qualqur número, mas se você treina no stado 1, tem que validar no 1, se treina no 42, tem que validar no 42.

Agora sim, podemos treinar, ou dar um match, fittar, nosso modelo com parte dos dados.

modelo_mDados = DecisionTreeRegressor(random_state=1), para definirmos qual estado da árvore de decisões

modelo_mDados.match(train_X, train_y), e aqui treinamos realmente o nosso modelo com os dados de treino, usando o estado randômico 1 da regressão de árvore de decisão, estamos treinando nosso judoca, ele vai aprender movimentos, golpes, contra golpes e estados da luta com esses dados.

Agora podemos usar os dados de validação para saber se o treino foi o suficiente:

val_predictions = modelo_mDados.predict(val_X), em que fazemos a predição (predict) com os valores de validação (val_X)

E agora vamos verificar o quanto “errado” nosso modelo está, quanto menor melhor, vamos usar outra ferramenta, a média de erros absoluta, absoluta pois não importa se é pra mais ou pra menos, o que nos interessa é o quanto pra fora dos valores alvo da validação (val_y) as nossas predições (val_predictions) estão:

val_mae = mean_absolute_error(val_predictions, val_y)

E agora nosso lutador foi posto à prova contra outros judocas, do nosso próprio dojô, mas agora não foram treinos, foram combates reais.

E agora nos deparamos com outro problema, o hiper-treinamento e o hipo-treinamento. Parece, num primeiro momento que o hiper-treinamento é benéfico, mas isso traz o problema de, no caso dos modelos, ter apenas pequenos, ou 1 caso, do treinamento que se encaixa quando for usado em testes reais, ou o erro é muito pequeno ou imenso, geralmente imenso.

Comparando com o nosso lutador, ou ele sabe exatamente o contra golpe ou fica empacado sem saber o que fazer, geralmente a segunda opção é mais comum. e o hipo-treinamento é o contrário, a árvore de decisão chega a um resultado muito genérico, o lutador usa qualquer golpe e em muitos casos não é o mais efetivo.

Apesar de computação ser exata, na prática essa exatidão cai com a qualidade dos dados, que quase nunca são livres de erros ou imprecisões, da habilidade do profissional de construir modelos bons, (treinados na medida certa, no meio termo entre muito e pouco) e do usuário final na interpretação dos dados.

Mas para isso temos um outro recurso de Info Science que é a definição de quantidade de ‘folhas’.

No gif acima, vemos árvores de decisão em funcionamento, os nossos modelos são bem representados assim, um modelo hiper-treinado (overfitting) é um modelo com muitas camadas, muitos nós de decisão e milhares, se não milhões, de folhas, que são as decisões ao final do processamento. Overfitting é quando apenas uma decisão, uma casa no exemplo dos imóveis, ou um movimento no caso do judoca é válido para determinada predição.

Um modelo hipo-treinado, ou underfitting, é o oposto, pouco treinado, com poucas camadas de decisão, ficando com previsões muito genéricas e vagas.

Em geral o underfitting já vai mal na validação dos modelos, o overfitting se mostra fraco já em produção, para evitar isso temos a ferramenta:

max_leaf_nodes, que com base nos dados de treino (train_X e train_y) e os de validação (val_X e val_y) verifica a média absoluta dos erros (suggest absolute error), no comando abaixo para 5, 50, 500, 5000 nós, ou camadas de decisão,

for max_leaf_nodes in [5, 50, 500, 5000]:

my_mae = get_mae(max_leaf_nodes, train_X, val_X, train_y, val_y)

print(“Max leaf nodes: %d tt Suggest Absolute Error: %d” %(max_leaf_nodes, my_mae))

E com isso refinando muito essa modelagem, que apesar de robusta ainda é simples em comparação com outras, como por exemplo a de RandomForest, a floresta randômica, que usa árvores variadas para melhorar os resultados dessa análise ainda mais.

Daqui em diante vamos acelerar o passo, vamos chamar nosso modelo de RandoForest com random_state igual a 1

rf_model = RandomForestRegressor(random_state=1)

Relembrando de dividir os dados entre treino e validação:

train_X, val_X, train_y, val_y = train_test_split(X, y, random_state=1)

Treinando o modelo: rf_model.match(train_X, train_y)

Validando ele: val_predictions = rf_model.predict(val_X)

Obs.: Separar a massa de dados para treino e validação é um passo importante, tanto pra estudo quanto pra trabalho

Calcular a média absoluta dos erros, Suggest Absolute Error — MAE:
rf_val_mae = mean_absolute_error(val_predictions, val_y)

Podemos colocar na tela os dados finais e verificar o refinamento dos modelos, ou do mae de cada modelo:

MAE do modelo de árvore sem especificar máximo de folhas: 29.653

MAE do modelo de árvore com número máximo de folhas: 27.283

MAE do modelo de RandomForest: 21.857

Basta olharmos para vermos que o refinamento atingiu quase 10 mil unidades, lembrando que essa é uma faixa de erro, para mais ou para menos, como no caso das eleições.

Nesse exemplo foram usadas casas, então podemos prever os seus preços com uma média de erro de 21.857 dinheiros , para mais ou para menos. Na sua opinião é muito? é pouco? Basta compara com os dados do pd.describe() que fizemos no começo do artigo. Quantos porcentos esse valor representa da casa mais cara? ou da mais barata? ou da média, só assim para sabermos de fato se nosso modelo é bom ou ruim, se precisa de mais trabalho ou não, antes de enviarmos para produção, apresentarmos aos clientes ou superiores, sejam supervisores, diretores, acionistas e até ao dono da empresa.

Gostou desse artigo? Que mais explicações, ou quem sabe até um vídeo, uma dwell explicando ponto a ponto, ou pegar um exemplo do Kaggle e trabalharmos juntos? Comenta aí, todo pedido será levado em conta!

Obrigado e até a próxima.