A gestão de stocks é um desafio crítico para a maioria das empresas de retalho. O excesso de stock imobiliza capital e aumenta o risco de obsolescência. A falta de stock, por outro lado, leva a vendas perdidas, a clientes insatisfeitos e a potenciais danos duradouros na marca. É por isso que uma previsão rigorosa da procura é essencial—não só para a eficiência operacional, mas também para a tomada de decisões estratégicas.
Neste artigo, vamos construir em Python um modelo de machine learning para prever a procura diária de produtos, usando um conjunto de dados real do retalho. No passo seguinte, vamos disponibilizar este modelo como uma API REST com Azure Functions, permitindo previsões em tempo real e à escala. Mais tarde, vamos usar o Power BI para visualizar a previsão e o Power Automate para disparar alertas quando for prevista uma rutura de stock.
📦 Conjunto de Dados e Problema de Negócio
O conjunto de dados vem do conjunto Retail Store Inventory Forecasting do Kaggle. Inclui mais de 73.000 registos com vendas de produtos em várias lojas. As colunas principais incluem:
- Date, Store ID, Product ID (data, loja e produto)
- Category, Region
- Weather Condition, Seasonality
- Inventory Level, Units Sold, Demand Forecast, Units Ordered (stock, unidades vendidas, procura prevista e unidades encomendadas)
- Price, Discount, Competitor Pricing
- Indicadores de Holiday/Promotion (feriado/promoção)
O nosso objetivo é prever as Units Sold (unidades vendidas) diárias com base nos dados históricos e em fatores externos. Com esta previsão, vamos conseguir detetar se o stock é suficiente para os dias seguintes e antecipar ruturas antes que aconteçam.
🤖 Porque é que Isto Importa
Ao usar um modelo de machine learning para prever a procura, abrimos caminho a decisões de stock mais inteligentes. Esta abordagem escala bem para milhares de produtos e de locais, adapta-se a padrões sazonais e regionais e dá às equipas uma vantagem proativa.
Não estamos apenas a criar um relatório—estamos a construir um sistema inteligente de apoio à decisão que liga dados, automação e operações.
🧠 Passo 1 – Carregar as Bibliotecas e Definir o Contexto
Comecemos por importar as bibliotecas que vamos usar e preparar o terreno para o treino do modelo.
# ===========================================
# DEMAND FORECASTING WITH RANDOM FOREST
# Dataset: Retail Store Inventory Forecasting
# ===========================================
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split, RandomizedSearchCV
from sklearn.metrics import mean_squared_error
from scipy.stats import randint
Este script prepara todas as ferramentas de que vamos precisar:
- pandas, numpy: para a manipulação de dados e operações numéricas.
- matplotlib, seaborn: para a visualização de distribuições e tendências.
- scikit-learn: para a construção do modelo, a divisão em treino e teste, a afinação e a avaliação.
- scipy.stats: para suportar a pesquisa aleatória durante a afinação do modelo.
Trata-se de bibliotecas consolidadas, prontas para produção e usadas em milhares de projetos reais de ciência de dados.
📂 Passo 2 – Carregar o Conjunto de Dados e Extrair Variáveis Temporais
O nosso conjunto de dados está guardado no Google Drive, pelo que o primeiro passo é montar o drive no ambiente Colab e ler o ficheiro CSV. Depois de carregados os dados, fazemos um pré-processamento básico, extraindo variáveis temporais como o mês, o dia da semana e o ano a partir da coluna de data.
Isto é importante porque a procura no retalho segue muitas vezes padrões sazonais e temporais fortes. Por exemplo:
- Os fins de semana podem ter mais vendas do que os dias úteis.
- Certos meses podem refletir procura sazonal (p. ex., épocas festivas, verão).
- O indicador do ano ajuda a captar tendências de longo prazo ou sazonalidade plurianual.
Eis o código que faz isto:
# -------------------------------------------
# Mount Google Drive
# -------------------------------------------
from google.colab import drive
drive.mount('/content/drive')
# -------------------------------------------
# STEP 1: Load dataset and initial processing
# -------------------------------------------
caminho_csv = "/content/drive/MyDrive/Datasets/retail_store_inventory.csv"
df = pd.read_csv(caminho_csv, parse_dates=["Date"])
# Convert 'Date' to datetime and extract temporal features
df['Date'] = pd.to_datetime(df['Date'])
df['Month'] = df['Date'].dt.month
df['DayOfWeek'] = df['Date'].dt.dayofweek
df['Year'] = df['Date'].dt.year
Estas novas colunas (Month, DayOfWeek, Year) vão ser usadas mais tarde como variáveis de entrada do nosso modelo de machine learning.
Ao incluir estas variáveis temporais, o modelo consegue aprender padrões como “as vendas disparam às sextas-feiras” ou “a procura cai em janeiro”, melhorando significativamente a precisão.
📊 Passo 3 – Análise Exploratória de Dados (EDA)
Antes de saltar para o treino do modelo, é importante explorar o conjunto de dados para perceber os padrões, detetar potenciais problemas e validar os nossos pressupostos.
Começamos por imprimir:
- Os tipos de dados de todas as colunas
- Os valores em falta
- As estatísticas descritivas dos campos numéricos
Depois, criamos três visualizações importantes:
# -------------------------------------------
# STEP 2: Exploratory Data Analysis (EDA)
# -------------------------------------------
# Overview
print("Data types:\n", df.dtypes)
print("\nMissing values:\n", df.isnull().sum())
print("\nSummary statistics:\n", df.describe())
# Distribution of target variable
sns.histplot(df['Units Sold'], bins=30, kde=True)
plt.title("Distribution of Units Sold")
plt.xlabel("Units Sold")
plt.ylabel("Frequency")
plt.show()
# Units Sold by Category
plt.figure(figsize=(10, 5))
sns.boxplot(x='Category', y='Units Sold', data=df)
plt.title("Units Sold by Category")
plt.xticks(rotation=45)
plt.show()
# Correlation heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(df.select_dtypes(include=[np.number]).corr(), annot=True, cmap='coolwarm')
plt.title("Correlation Matrix")
plt.show()
🔍 O que os Dados Revelam
- As estatísticas descritivas revelam que, em média, são vendidas cerca de 136 unidades por registo, com um desvio-padrão de 108 unidades. Os preços variam entre 10 € e 100 €, e os níveis de stock chegam às 600 unidades. As promoções estão ativas cerca de 50% do tempo.

- O histograma das Units Sold mostra uma distribuição assimétrica à direita. A maioria dos produtos vende menos de 100 unidades por dia, mas uma cauda longa estende-se até às 500 unidades. Esta assimetria pode afetar o desempenho do modelo e poderá beneficiar de uma transformação logarítmica em versões mais avançadas.

- O boxplot por Category indica que a mediana da procura é semelhante entre os tipos de produto, mas a dispersão e o número de outliers variam. As categorias Electronics e Furniture mostram maior variância, enquanto Clothing e Toys são mais estáveis.

- O mapa de calor das correlações revela uma correlação forte entre
Units Sold,Inventory LeveleDemand Forecast, o que é esperado e útil para a modelação preditiva. No entanto,PriceeCompetitor Pricingestão quase perfeitamente correlacionados (0,99), o que pode introduzir multicolinearidade se ambos forem usados como variáveis.
Estes passos de EDA ajudam a validar a nossa intuição e dão a base para a engenharia de variáveis e a escolha do modelo.
🧼 Passo 4 – Pré-processamento dos Dados
Depois de compreender os dados, é preciso prepará-los para o machine learning. A maioria dos algoritmos de ML, incluindo as Random Forests, só aceita inputs numéricos. Isso significa que temos de transformar as variáveis categóricas num formato que o modelo consiga entender.
Usamos one-hot encoding para converter as categorias (como a região ou o tipo de produto) em colunas binárias, em que cada valor possível passa a ser uma nova variável.
Depois, definimos as nossas variáveis de entrada (X) e a variável-alvo (y), que neste caso é o número de unidades vendidas.
# -------------------------------------------
# STEP 2: Data preprocessing
# -------------------------------------------
# One-hot encoding
df_model = pd.get_dummies(df, columns=[
'Store ID', 'Product ID', 'Category', 'Region',
'Weather Condition', 'Seasonality'
])
# Define features (X) and target (y)
X = df_model.drop(columns=['Units Sold', 'Date'])
y = df_model['Units Sold']
Temos agora um conjunto de dados limpo e estruturado, totalmente numérico e pronto a alimentar um modelo de machine learning. Este é um dos passos mais importantes para garantir previsões rigorosas.
🌲 Passo 5 – Divisão Treino/Teste e Treino do Modelo
Com as variáveis e o alvo definidos, dividimos agora o conjunto de dados num conjunto de treino e num conjunto de teste. Isto permite treinar o modelo com uma parte dos dados e avaliá-lo com dados que nunca viu, para medir a sua capacidade de generalização.
Usamos uma divisão 80/20 e treinamos um Random Forest Regressor com os melhores hiperparâmetros encontrados previamente através de uma pesquisa aleatória.
# -------------------------------------------
# STEP 3: Train/test split and model training
# -------------------------------------------
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
best_model = RandomForestRegressor(
n_estimators=124,
max_depth=9,
min_samples_split=8,
min_samples_leaf=3,
random_state=42
)
best_model.fit(X_train, y_train)
Os hiperparâmetros selecionados equilibram a complexidade do modelo e a prevenção do sobreajustamento (overfitting):
n_estimators=124: número de árvores na florestamax_depth=9: limita a profundidade de cada árvore para controlar o overfittingmin_samples_split=8: número mínimo de amostras necessário para dividir um nó internomin_samples_leaf=3: número mínimo de amostras necessário num nó folha
Estes parâmetros foram selecionados com base num processo de afinação com RandomizedSearchCV. A imagem abaixo mostra a configuração do modelo resultante no Colab:

A seguir, vamos avaliar o desempenho do modelo com o RMSE e analisar os resultados das previsões.
📏 Passo 6 – Avaliar o Desempenho do Modelo
Depois de treinado o modelo, precisamos de avaliar o seu desempenho com dados que nunca viu. Para isso, usamos o conjunto de teste para gerar previsões e calcular o Root Mean Squared Error (RMSE), ou raiz do erro quadrático médio—uma métrica padrão para problemas de regressão.
O RMSE dá-nos uma noção do erro médio de previsão nas mesmas unidades da variável-alvo (unidades vendidas).
# -------------------------------------------
# STEP 4: Evaluate model performance
# -------------------------------------------
y_pred = best_model.predict(X_test)
# Calculate Mean Squared Error and then take the square root for RMSE
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
print(f"✅ Root Mean Squared Error: {rmse:.2f}")
✅ Root Mean Squared Error (raiz do erro quadrático médio): 8.37
Isto significa que, em média, a previsão do nosso modelo se desvia cerca de 8,37 unidades por registo. Tendo em conta que as vendas diárias variam entre 0 e 500 e que o desvio-padrão é superior a 100, trata-se de um resultado muito bom para uma primeira iteração que usa apenas variáveis históricas.
No passo seguinte, vamos guardar o modelo e começar o processo de o pôr em produção como uma API REST com Azure Functions.
💾 Passo 7 – Exportar o Modelo
Depois de treinar e validar o modelo, exportamo-lo com joblib. Isto permite reutilizar o modelo treinado num ambiente de produção, como um serviço web ou um endpoint de API.
No próximo artigo, vamos disponibilizar este modelo com Azure Functions, para servir previsões em tempo real através de pedidos HTTP.
# -------------------------------------------
# STEP 5: Export model to .pkl
# -------------------------------------------
import joblib
joblib.dump(best_model, "modelo_previsao_vendas.pkl")
Este comando serializa todo o objeto do modelo num ficheiro binário chamado modelo_previsao_vendas.pkl, que pode ser carregado mais tarde em qualquer ambiente Python sem ser preciso voltar a treinar o modelo.
No próximo artigo, vamos mostrar como:
- Disponibilizar este modelo num ambiente serverless com Azure Functions
- Criar uma API REST para servir as previsões
- Consumir a API a partir do Power BI ou do Power Apps
🚀 Fique atento à Parte 2: “Disponibilizar o Modelo de Previsão da Procura com Azure Functions”





