Previsão da Temperatura Média de Londres com Machine Learning e MLflow

Casos de Estudo — Previsão da Temperatura Média de Londres com Machine Learning e MLflow

Introdução

Projetos de Machine Learning não terminam quando um modelo consegue realizar uma previsão. Em um ambiente profissional, é necessário construir um processo que permita preparar os dados, treinar diferentes algoritmos, avaliar seus resultados, registrar experimentos e comparar modelos de maneira reproduzível.

Este caso de estudo apresenta o desenvolvimento de um projeto de Engenharia de Machine Learning para previsão da temperatura média de Londres, utilizando dados meteorológicos históricos e ferramentas amplamente utilizadas no ecossistema Python.

O objetivo principal foi desenvolver modelos capazes de prever a variável mean_temp, que representa a temperatura média, buscando um RMSE (Root Mean Squared Error) igual ou inferior a 3.

Além da capacidade preditiva, o projeto foi estruturado para registrar os experimentos realizados utilizando MLflow, permitindo acompanhar modelos, hiperparâmetros, métricas e execuções.

A solução utiliza principalmente:

• Python
• Pandas
• NumPy
• Scikit-learn
• MLflow
• Regressão Linear
• Decision Tree Regressor
• Random Forest Regressor
• SimpleImputer
• RMSE como métrica de avaliação

O resultado é um pequeno pipeline experimental que demonstra conceitos importantes de Data Science, Machine Learning Engineering e MLOps.

---

1. O problema de Machine Learning

O dataset utilizado contém 15.341 observações meteorológicas e dez variáveis relacionadas às condições climáticas de Londres.

Entre as informações disponíveis estão:

date — data da observação;

cloud_cover — cobertura de nuvens;

sunshine — quantidade de luz solar;

global_radiation — radiação global;

max_temp — temperatura máxima;

mean_temp — temperatura média;

min_temp — temperatura mínima;

precipitation — precipitação;

pressure — pressão atmosférica;

snow_depth — profundidade da neve.

A variável que queremos prever é:

mean_temp

Como a temperatura é um valor numérico contínuo, estamos diante de um problema de aprendizado supervisionado de regressão.

Matematicamente, queremos construir uma função capaz de aprender uma relação aproximada:

X → modelo → temperatura média

onde X representa as características meteorológicas utilizadas como entrada.

---

2. Análise inicial dos dados

Antes do treinamento dos modelos, foi realizada uma inspeção do dataset.

Em Python:

weather = pd.read_csv("london_weather.csv")

print(weather.head())
print(weather.info())
print(weather.isna().sum())

Essa etapa revelou uma característica importante: o conjunto de dados apresentava valores ausentes.

Entre eles:

cloud_cover           19
global_radiation      19
max_temp               6
mean_temp             36
min_temp               2
precipitation          6
pressure               4
snow_depth          1441

Essa descoberta exigiu uma estratégia de preparação dos dados antes que os algoritmos fossem treinados.

---

3. Tratamento dos valores ausentes

Um dos pontos mais importantes deste projeto foi diferenciar valores ausentes presentes nas features daqueles existentes na variável target.

Nossa variável target é:

mean_temp

Foram encontrados 36 registros nos quais essa informação estava ausente.

Não seria adequado simplesmente estimar esses valores e utilizá-los como verdade durante o treinamento, pois estaríamos criando artificialmente justamente a informação que o modelo precisa aprender a prever.

Por isso, esses registros foram removidos:

weather = weather.dropna(subset=["mean_temp"])

Depois desse procedimento, foram criadas as features e o target:

X = weather.drop(columns=["mean_temp", "date"])
y = weather["mean_temp"]

A coluna date também foi removida da primeira versão do modelo, evitando que sua representação numérica bruta fosse interpretada diretamente como uma variável quantitativa comum.

---

4. Separação entre treinamento e teste

Para avaliar corretamente um modelo de Machine Learning, não devemos medir seu desempenho apenas utilizando os mesmos dados empregados no treinamento.

Os dados foram, portanto, separados entre treinamento e teste:

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

Nesse caso:

80% → treinamento
20% → teste

O parâmetro:

random_state=42

contribui para a reprodutibilidade do experimento, fazendo com que a divisão dos dados possa ser reproduzida em execuções futuras.

Reprodutibilidade é um requisito importante em Engenharia de Machine Learning, principalmente quando diferentes modelos e configurações precisam ser comparados.

---

5. Imputação dos valores ausentes nas features

Ainda existiam valores ausentes nas variáveis utilizadas como entrada do modelo.

Para tratá-los foi utilizado o SimpleImputer do Scikit-learn:

imputer = SimpleImputer(strategy="median")

O imputador aprende os valores utilizando somente o conjunto de treinamento:

X_train = imputer.fit_transform(X_train)

Posteriormente, a mesma transformação é aplicada aos dados de teste:

X_test = imputer.transform(X_test)

Essa separação é fundamental para evitar data leakage.

O conjunto de teste deve representar dados que o modelo ainda não conhece. Permitir que informações dele participem da preparação do treinamento poderia produzir uma avaliação artificialmente otimista.

---

6. Modelos avaliados

Em vez de escolher um único algoritmo antecipadamente, o projeto utiliza uma abordagem experimental.

Foram avaliados três algoritmos de regressão:

Linear Regression

A Regressão Linear foi utilizada como modelo inicial e baseline.

model = LinearRegression()

Um modelo simples é extremamente útil porque estabelece uma referência para comparação.

Se algoritmos significativamente mais complexos não conseguirem superar essa referência, talvez a complexidade adicional não seja justificável.

Decision Tree Regressor

O segundo algoritmo utilizado foi uma árvore de decisão:

model = DecisionTreeRegressor(
    max_depth=10,
    random_state=42
)

As árvores conseguem capturar relações não lineares entre as características dos dados.

O parâmetro max_depth controla a profundidade máxima da árvore e também ajuda a limitar sua complexidade.

Random Forest Regressor

O terceiro modelo foi o Random Forest:

model = RandomForestRegressor(
    n_estimators=100,
    max_depth=10,
    random_state=42
)

Random Forest é um método de ensemble que combina diversas árvores de decisão.

Neste experimento foram utilizadas 100 árvores:

n_estimators=100

A expectativa é que a combinação de várias árvores produza previsões mais robustas do que depender de uma única árvore.

---

7. Avaliação utilizando RMSE

Para comparar os modelos foi utilizado o Root Mean Squared Error (RMSE).

O cálculo foi realizado da seguinte maneira:

rmse = np.sqrt(
    mean_squared_error(y_test, predictions)
)

O RMSE mede, na mesma unidade da variável prevista, o tamanho típico dos erros do modelo, penalizando de maneira mais intensa erros maiores devido ao componente quadrático.

Neste projeto foi estabelecido como requisito:

RMSE ≤ 3

Portanto, quanto menor o resultado obtido, melhor o desempenho preditivo do modelo.

Essa definição prévia de uma métrica também é importante em projetos profissionais: um modelo deve ser avaliado em relação a um critério objetivo, e não apenas pela impressão de que suas previsões parecem boas.

---

8. Rastreamento dos experimentos com MLflow

Uma das partes centrais do projeto foi a utilização do MLflow.

O experimento foi definido como:

mlflow.set_experiment(
    "London Weather Prediction"
)

Cada treinamento passou a ser executado dentro de um MLflow Run:

with mlflow.start_run():

A partir disso, diferentes informações podem ser armazenadas.

Por exemplo, hiperparâmetros:

mlflow.log_param("n_estimators", 100)
mlflow.log_param("max_depth", 10)

Métricas:

mlflow.log_metric("rmse", rmse)

E o próprio modelo treinado:

mlflow.sklearn.log_model(
    model,
    "model"
)

Essa abordagem transforma uma sequência de treinamentos em um processo rastreável.

Em vez de manter resultados manualmente em anotações ou depender da memória do desenvolvedor, cada execução passa a possuir informações sobre o algoritmo, configurações utilizadas e desempenho obtido.

---

9. Comparação automática dos experimentos

Depois dos treinamentos, os runs registrados foram recuperados utilizando:

experiment_results = mlflow.search_runs(
    experiment_ids=[experiment.experiment_id]
)

Os resultados podem então ser ordenados pelo RMSE:

experiment_results = experiment_results.sort_values(
    "metrics.rmse",
    ascending=True
)

Como um RMSE menor representa melhor desempenho, o primeiro registro passa a representar o melhor resultado encontrado entre os experimentos avaliados.

Isso permite transformar o processo em algo semelhante a:

Dados históricos
      ↓
Preparação
      ↓
Treinamento
      ↓
Linear Regression ───→ RMSE
Decision Tree ───────→ RMSE
Random Forest ───────→ RMSE
      ↓
MLflow Tracking
      ↓
Comparação dos Runs
      ↓
Seleção do melhor resultado

---

10. Engenharia de Machine Learning além do treinamento

Um dos principais aprendizados deste caso de estudo é que desenvolver um sistema de Machine Learning envolve muito mais do que executar:

model.fit()

Foi necessário construir um fluxo envolvendo:

Preparação dos dados → Tratamento de valores ausentes → Separação treino/teste → Treinamento → Predição → Avaliação → Rastreamento → Comparação.

Esse processo representa uma introdução prática ao ciclo de vida de Machine Learning.

MLflow acrescenta uma camada particularmente importante: experiment tracking.

À medida que um projeto cresce, podemos ter dezenas ou centenas de combinações de algoritmos e hiperparâmetros. Sem uma ferramenta de rastreamento, descobrir exatamente qual configuração gerou determinado resultado pode se tornar difícil.

---

11. Possíveis evoluções do projeto

Embora a solução construída já permita desenvolver e comparar modelos, existem diversas possibilidades de evolução.

Uma delas seria transformar a coluna date em informações temporais úteis, como:

ano
mês
dia
estação do ano

Isso permitiria ao modelo capturar melhor a sazonalidade do clima.

Também seria possível utilizar técnicas como:

• Cross-validation;
• Grid Search;
• Randomized Search;
• Feature Engineering;
• Feature Selection;
• Pipelines do Scikit-learn;
• Hyperparameter Tuning;
• Model Registry;
• versionamento dos modelos;
• deployment do melhor modelo;
• monitoramento de performance;
• detecção de data drift.

Outra evolução interessante seria transformar a preparação dos dados e o modelo em um único Pipeline do Scikit-learn, garantindo que exatamente as mesmas transformações utilizadas durante o treinamento sejam posteriormente aplicadas durante a inferência.

---

Conclusão

O projeto London Weather Prediction demonstra como um problema aparentemente simples de previsão pode ser estruturado utilizando princípios importantes de Engenharia de Machine Learning.

Partimos de um dataset meteorológico contendo 15.341 observações, identificamos problemas de qualidade nos dados, tratamos valores ausentes de maneira diferente para features e target, dividimos os dados entre treinamento e teste e avaliamos diferentes algoritmos de regressão.

Mais importante do que simplesmente treinar os modelos, cada experimento foi acompanhado utilizando MLflow, registrando métricas, parâmetros e modelos.

Com isso, o projeto passou de um simples treinamento isolado para um fluxo experimental rastreável e reproduzível.

Essa diferença é fundamental.

Em Data Science, frequentemente buscamos responder à pergunta:

Qual modelo consegue resolver melhor este problema?

Em Engenharia de Machine Learning precisamos ir além:

Como podemos treinar, avaliar, rastrear, reproduzir, comparar e posteriormente disponibilizar esse modelo de maneira confiável?

É justamente nessa transição que ferramentas como Scikit-learn e MLflow se complementam.

O Scikit-learn fornece os componentes necessários para preparação, treinamento e avaliação dos modelos, enquanto o MLflow cria a infraestrutura necessária para acompanhar o ciclo experimental.

O resultado é uma base sólida para projetos maiores, nos quais modelos deixam de ser apenas experimentos executados em notebooks e passam a fazer parte de sistemas de Machine Learning reproduzíveis, versionáveis e preparados para futuras etapas de produção.