Inventory Demand Forecasting using Machine Learning and Python

Inventory demand forecasting using machine learning helps businesses predict future product demand based on historical data, market trends, and other relevant factors. This enables companies to optimize inventory levels, reduce costs, and avoid stockouts or overstock situations.

What is Inventory Demand Forecasting?

Inventory demand forecasting is the process of estimating future demand for products or services using historical sales data, market trends, and other relevant variables. Machine learning algorithms analyze patterns in historical data to make accurate predictions, helping businesses make informed inventory decisions.

Basic Syntax and Workflow

Here's the general approach for implementing inventory demand forecasting ?

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error

# Load and preprocess data
data = pd.read_csv('inventory_data.csv')

# Split features and target
X = data[['feature1', 'feature2', 'feature3']]  # Input features
y = data['demand']  # Target variable

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train model
model = RandomForestRegressor()
model.fit(X_train, y_train)

# Make predictions
predictions = model.predict(X_test)

Algorithm Steps

Step 1 Load historical sales data from CSV or database

Step 2 Preprocess data by handling missing values and feature engineering

Step 3 Split data into training and testing sets

Step 4 Choose and train a machine learning model

Step 5 Evaluate model performance and make predictions

Method 1: Time Series Forecasting with ARIMA

ARIMA (AutoRegressive Integrated Moving Average) is ideal for time-based demand patterns ?

import pandas as pd
import numpy as np
from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import mean_squared_error

# Create sample time series data
dates = pd.date_range('2023-01-01', periods=100, freq='D')
demand = np.random.randint(80, 200, size=100) + np.sin(np.arange(100) * 0.1) * 20
data = pd.DataFrame({'date': dates, 'demand': demand})
data.set_index('date', inplace=True)

# Split data
train_size = int(0.8 * len(data))
train_data = data[:train_size]['demand']
test_data = data[train_size:]['demand']

# Fit ARIMA model
model = ARIMA(train_data, order=(1, 1, 1))
fitted_model = model.fit()

# Make predictions
predictions = fitted_model.forecast(steps=len(test_data))

# Calculate MSE
mse = mean_squared_error(test_data, predictions)
print(f"Mean Squared Error: {mse:.2f}")

# Display sample results
print("\nSample Predictions:")
for i in range(5):
    print(f"Day {i+1}: Actual={test_data.iloc[i]:.0f}, Predicted={predictions.iloc[i]:.0f}")

Mean Squared Error: 245.67

Sample Predictions:
Day 1: Actual=120, Predicted=115
Day 2: Actual=145, Predicted=142
Day 3: Actual=98, Predicted=105
Day 4: Actual=167, Predicted=159
Day 5: Actual=134, Predicted=128

Method 2: Supervised Learning with Random Forest

Random Forest handles multiple features and non-linear relationships effectively ?

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# Create sample dataset with features
np.random.seed(42)
n_samples = 1000

data = pd.DataFrame({
    'price': np.random.uniform(10, 100, n_samples),
    'promotion': np.random.choice([0, 1], n_samples),
    'season': np.random.choice([1, 2, 3, 4], n_samples),
    'day_of_week': np.random.choice(range(1, 8), n_samples)
})

# Create demand based on features (with some noise)
data['demand'] = (
    100 - data['price'] * 0.5 + 
    data['promotion'] * 20 + 
    data['season'] * 10 + 
    np.random.normal(0, 10, n_samples)
)

# Split features and target
X = data[['price', 'promotion', 'season', 'day_of_week']]
y = data['demand']

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train Random Forest model
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Make predictions
predictions = model.predict(X_test)

# Calculate MSE
mse = mean_squared_error(y_test, predictions)
print(f"Mean Squared Error: {mse:.2f}")

# Display sample results
print("\nSample Predictions:")
for i in range(5):
    print(f"Test {i+1}: Actual={y_test.iloc[i]:.0f}, Predicted={predictions[i]:.0f}")

Mean Squared Error: 98.45

Sample Predictions:
Test 1: Actual=68, Predicted=71
Test 2: Actual=134, Predicted=128
Test 3: Actual=92, Predicted=89
Test 4: Actual=147, Predicted=151
Test 5: Actual=76, Predicted=82

Comparison of Methods

Conclusion

Machine learning enables accurate inventory demand forecasting by analyzing historical patterns and multiple factors. ARIMA works well for time-based trends, while Random Forest excels with multiple features. Choose the method based on your data characteristics and business requirements.