A Jornada do Cientista de Dados: Navegando Pelos Modelos e o Poder da Curiosidade
A Jornada do Cientista de Dados: Navegando Pelos Modelos e o Poder da Curiosidade
Como um programador experiente na área de ciência de dados, costumo dizer: "Qual o próximo passo?". Essa pergunta é a bússola que nos guia em nossa jornada, pois mais importante do que o destino final é o caminho que escolhemos trilhar. No universo da computação, essa premissa não é diferente.
O Alicerce da Comunicação: Inglês e Linguagens de Máquina
Primeiramente, para navegar com fluidez nesse ecossistema, o inglês é o idioma universal. Não me refiro à perfeição gramatical ou à complexidade do inglês britânico. Para começar, um vocabulário mínimo e a capacidade de compreender textos técnicos já são suficientes. Afinal, como minha frase favorita diz: "Sempre se mantenha curioso, é mais produtivo viver com o peso da busca que com o vazio da ignorância."
Com o inglês em dia, é hora de aprender a linguagem que as máquinas utilizam. No meu caso, o Python é a escolha óbvia. Embora derive do inglês, seus comandos e estruturas formam um vocabulário próprio. Quanto mais você dominar o que está "mandando" a máquina fazer, mais fácil será interpretar códigos de outros, utilizar soluções de fóruns e colaborar com colegas. Copiar e colar te levará apenas alguns metros; a jornada, no entanto, é de milhares de quilômetros.
Decifrando o Futuro: A Essência do Machine Learning
Com as ferramentas básicas em mãos – inglês e Python – o verdadeiro "próximo passo" é o Machine Learning (ML), ou Aprendizado de Máquina. Aqui, o objetivo é ensinar as máquinas a construir, treinar, refinar e validar modelos de análise de dados.
Onde começar essa exploração? A internet é um vasto oceano de informações. Recomendo o TechGuide da Alura e o Kaggle, uma plataforma fantástica para competições de ciência de dados. No YouTube, o Mario Filho oferece playlists bem organizadas sobre Machine Learning e desafios do Kaggle, que são excelentes pontos de partida.
Munido desses recursos, a receita é simples: sente-se, prepare alguns litros de café, algo para comer e mergulhe em leituras, vídeos e estudos.
Construindo Modelos: Da Teoria à Prática com Python
Em sua essência, Machine Learning envolve a criação de modelos em Python para processar grandes volumes de dados e "treinar" a máquina. Mas o que exatamente são esses modelos?
Modelos são construções a partir de bibliotecas Python. Começamos com o Pandas, uma ferramenta indispensável para carregar e manipular arquivos de dados, geralmente exportações de grandes tabelas do Excel ou similares. Enquanto o Excel pode se curvar sob o peso de milhares de linhas e colunas, o Pandas nos oferece funções internas poderosas como `describe()`, que nos fornece um panorama estatístico rápido, incluindo total de linhas, colunas, média, mediana e quartis.
A magia do ML começa a se materializar com o scikit-learn (sklearn). Com ele, podemos implementar modelos como a Árvore de Decisão (DecisionTreeRegressor), que oferece uma predição robusta, e a Floresta Aleatória (RandomForestRegressor), uma evolução da Árvore de Decisão que aprimora ainda mais o desempenho.
O Coração do Modelo: Previsão e Parâmetros
Como esses modelos geram resultados? Simples: pegamos nossa massa de dados, definimos qual coluna é nosso alvo (aquilo que queremos prever) e utilizamos as outras colunas (ou parte delas) como parâmetros para essa definição.
Vamos exemplificar com um cenário real: a previsão de preços de imóveis. Imagine uma planilha com informações sobre casas, incluindo área construída, número de quartos, banheiros e ano de construção. Para quem já procurou um imóvel, sabe o quão crucial esses detalhes são.
Nosso **alvo ($y$)** será o preço do imóvel ($y = \text{valorImóvel}$), e nossos parâmetros ($X$) serão as características: $X = [\text{‘tamanho de área construída’}, \text{‘número de quartos’}, \text{‘banheiros’}, \text{‘ano de construção’}]$.
Nosso modelo, portanto, buscará prever $y$ em função de $X$. O primeiro passo é treinar o modelo. Treinar significa calibrar a previsão para $y$ utilizando os parâmetros $X$. É um processo mental semelhante ao que um corretor de imóveis faz: ele pondera cada característica – tamanho, número de cômodos, depreciação por idade, reformas – para estimar o valor de mercado. Estamos aqui simplificando, mas a essência é essa.
Após o treinamento, o modelo pode prever valores para novos imóveis em um piscar de olhos, seja para um único caso ou para uma massa de dados de milhões de registros. É para isso que a Ciência de Dados serve: criar modelos que facilitem o trabalho humano, transformando dias ou semanas de análise manual em resultados quase instantâneos.
Validando o Conhecimento: O Dilema do Overfitting e Underfitting
No entanto, um modelo bem treinado não é necessariamente um modelo validado. Imagine um lutador de judô que treinou apenas com seus colegas de dojo. Ele "decorou" os movimentos deles, mas não foi testado contra adversários reais. Da mesma forma, um modelo treinado com todos os dados pode falhar miseravelmente em um novo cenário se não for validado.
Para isso, usamos a ferramenta `train_test_split` do `sklearn`. Primeiramente, nossa massa de dados (`mDados`) é carregada com Pandas: `mDados = pd.read_csv(dados.csv)`. Definimos nosso alvo $y = \text{mDados.valorImóvel}$ e nossos *features* $X = [\text{‘tamanho de área construída’}, \text{‘número de quartos’}, \text{‘banheiros’}, \text{‘ano de construção’}]$.
O comando `train_X, val_X, train_y, val_y = train_test_split(X, y, random_state=1)` divide nossos dados em conjuntos de treino e validação. O `random_state` garante a reprodutibilidade dos resultados, crucial para testes e validações.
Agora, treinamos (ou "fittamos") nosso modelo. Por exemplo, com `modelo_mDados = DecisionTreeRegressor(random_state=1)` e `modelo_mDados.fit(train_X, train_y)`. Nosso "judoca" agora está aprendendo os golpes com os dados de treino.
Em seguida, usamos os dados de validação para testar a performance do modelo: `val_predictions = modelo_mDados.predict(val_X)`. Para quantificar o quão "errado" nosso modelo está, utilizamos a Média de Erros Absoluta (MAE): `val_mae = mean_absolute_error(val_predictions, val_y)`. O MAE nos diz o desvio médio absoluto entre as previsões e os valores reais, independentemente da direção do erro.
Otimização Fina: Controlando a Complexidade dos Modelos
É nesse ponto que nos deparamos com dois problemas cruciais: hiper-treinamento (overfitting) e hipo-treinamento (underfitting).
O overfitting ocorre quando o modelo é treinado demais, "decorando" os dados de treino a ponto de não generalizar bem para novos dados. É como o lutador que só sabe o contra-golpe exato para um movimento específico de um colega. Em cenários reais, ele pode ficar estagnado.
O underfitting, por outro lado, é quando o modelo é pouco treinado e suas previsões são muito genéricas, como um lutador que usa qualquer golpe, mas raramente o mais efetivo.
Para mitigar o overfitting, especialmente em Árvores de Decisão, utilizamos o parâmetro `max_leaf_nodes`. Ele nos permite controlar a complexidade do modelo, buscando o ponto ideal onde o MAE é minimizado, evitando tanto a superespecialização quanto a generalização excessiva.
```python
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 \t\t Mean Absolute Error: %d" % (max_leaf_nodes, my_mae))
Ao otimizar esse parâmetro, refinamos a modelagem. No entanto, mesmo com essa otimização, modelos como a Floresta Aleatória (RandomForestRegressor) costumam superar as Árvores de Decisão simples.
Vamos criar e treinar um modelo de RandomForestRegressor:
```python
rf_model = RandomForestRegressor(random_state=1)
train_X, val_X, train_y, val_y = train_test_split(X, y, random_state=1) # Relembrando a divisão
rf_model.fit(train_X, train_y)
val_predictions = rf_model.predict(val_X)
rf_val_mae = mean_absolute_error(val_predictions, val_y)
A separação dos dados para treino e validação é um passo fundamental, tanto para o aprendizado quanto para a aplicação prática.
A Prova Final: Comparando os Resultados
Ao comparar os MAEs de diferentes modelos, a evolução se torna evidente:
* 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
A redução do MAE demonstra o refinamento e a melhoria dos modelos. Em nosso exemplo de previsão de preços de casas, uma média de erro de 21.857 "dinheiros" (unidades monetárias) para mais ou para menos. Mas o que esse número realmente significa? É muito? É pouco?
Para responder a essa pergunta, é crucial compará-lo com os dados descritivos obtidos no início do artigo (com `pd.describe()`). Qual a porcentagem que esse erro representa em relação ao preço da casa mais cara, da mais barata ou da média? Somente essa análise contextual pode nos dizer se o modelo é realmente bom ou se precisa de mais trabalho antes de ser implementado em produção ou apresentado a clientes e superiores.
Essa jornada pela criação e validação de modelos de Machine Learning é apenas o começo. A Ciência de Dados é um campo vasto e em constante evolução, onde a curiosidade e a busca contínua por conhecimento são os maiores aliados.
Gostou do artigo? Quer mais explicações detalhadas, um vídeo, uma live, ou talvez trabalhar juntos em um desafio do Kaggle? Compartilhe seus comentários e sugestões. Toda opinião é valiosa e será considerada!
Obrigado e até a próxima!
