Real-Time Inventory Management

Abstract

An append-only event log of receipts and sales, replayed to give stock on hand at any moment. Nothing is edited in place, so every stock figure traces back to the movements that produced it. The output that matters is not the stock level but the stockout count: at a reorder point of 10 the simulation records 21 stockouts and 130 lost units; at 40 it records zero, holding 49.5 units on average instead of 29.5.

Prerequisites

Python 3.8 or above
A code editor or IDE
Basic understanding of ML and analytics
Required libraries: pandas, scikit-learn, matplotlib

Before you Start

Install Python and the required libraries:

Install dependencies

pip install pandas scikit-learn matplotlib

Getting Started

Create a Project

Create a folder named real-time-inventory-management.
Open the folder in your code editor or IDE.
Create a file named real_time_inventory_management.py.
Copy the code below into your file.

Write the Code

Real-Time Inventory Management

pch.viewSource

Real-Time Inventory Management

"""Real-time inventory management.

An append-only event log of receipts and sales, replayed to give stock on hand
at any moment. Each SKU has a reorder point and a lead time, so the interesting
output is not the stock level but the count of **stockouts** -- the times demand
arrived and there was nothing to sell.
"""

from collections import defaultdict

import matplotlib.pyplot as plt
import numpy as np


class InventoryLedger:
    """Append-only events; stock is always derived, never edited in place.

    Storing the events rather than a running total is what makes the history
    auditable: any stock figure can be traced to the movements that produced it.
    """

    def __init__(self):
        self.events = []

    def receive(self, period, sku, quantity):
        self.events.append((period, sku, "receive", int(quantity)))

    def sell(self, period, sku, quantity):
        self.events.append((period, sku, "sell", int(quantity)))

    def on_hand(self, sku=None):
        totals = defaultdict(int)
        for _, item, kind, quantity in self.events:
            totals[item] += quantity if kind == "receive" else -quantity
        return totals if sku is None else totals[sku]

    def history(self, sku):
        level, out = 0, []
        for _, item, kind, quantity in self.events:
            if item != sku:
                continue
            level += quantity if kind == "receive" else -quantity
            out.append(level)
        return out


class ReorderPolicy:
    """Order `quantity` whenever stock falls to `point`; arrives after `lead`."""

    def __init__(self, point, quantity, lead=3):
        self.point = point
        self.quantity = quantity
        self.lead = lead


def simulate(policy, periods=120, mean_demand=8.0, seed=0):
    rng = np.random.default_rng(seed)
    ledger = InventoryLedger()
    ledger.receive(0, "WIDGET", policy.quantity)
    incoming, stockouts, lost = {}, 0, 0

    for period in range(1, periods + 1):
        if period in incoming:
            ledger.receive(period, "WIDGET", incoming.pop(period))

        demand = int(rng.poisson(mean_demand))
        available = ledger.on_hand("WIDGET")
        sold = min(demand, available)
        if sold:
            ledger.sell(period, "WIDGET", sold)
        if demand > available:
            stockouts += 1
            lost += demand - available

        outstanding = sum(incoming.values())
        if ledger.on_hand("WIDGET") + outstanding <= policy.point:
            incoming[period + policy.lead] = (
                incoming.get(period + policy.lead, 0) + policy.quantity)

    return {"ledger": ledger, "stockouts": stockouts, "lost": lost,
            "events": len(ledger.events),
            "levels": ledger.history("WIDGET")}


def main():
    print("Real-Time Inventory Management")
    print(f"  {'reorder point':>14} {'order qty':>10} {'stockouts':>10} "
          f"{'lost units':>11} {'mean stock':>11}")

    results = []
    for point in (10, 25, 40, 60):
        policy = ReorderPolicy(point=point, quantity=60)
        result = simulate(policy)
        levels = np.asarray(result["levels"], dtype=float)
        results.append((point, result, levels.mean()))
        print(f"  {point:>14} {policy.quantity:>10} "
              f"{result['stockouts']:>10} {result['lost']:>11} "
              f"{levels.mean():>11.1f}")

    best = min(results, key=lambda row: (row[1]["stockouts"], row[2]))
    print(f"\n  fewest stockouts at reorder point {best[0]} "
          f"({best[1]['stockouts']} over 120 periods)")
    print("  holding more stock buys fewer stockouts and costs carrying space")
    print(f"  every figure above is derived from "
          f"{best[1]['events']} logged events, not a stored total")

    figure, axes = plt.subplots(1, 2, figsize=(9.5, 3.6))
    for point, result, _ in results:
        axes[0].plot(result["levels"], linewidth=1.1,
                     label=f"reorder at {point}")
    axes[0].axhline(0, color="black", linewidth=0.8, linestyle=":")
    axes[0].set_xlabel("movement")
    axes[0].set_ylabel("units on hand")
    axes[0].set_title("stock derived from the event log")
    axes[0].legend(fontsize=7)

    points = [row[0] for row in results]
    axes[1].bar([str(p) for p in points],
                [row[1]["stockouts"] for row in results])
    for index, row in enumerate(results):
        axes[1].annotate(str(row[1]["stockouts"]), (index, row[1]["stockouts"]),
                         ha="center", va="bottom", fontsize=8)
    axes[1].set_xlabel("reorder point")
    axes[1].set_ylabel("periods with a stockout")
    axes[1].set_title("the number the policy is chosen on")
    figure.tight_layout()
    plt.savefig("real_time_inventory_management.png", dpi=120,
                bbox_inches="tight")
    print("saved real_time_inventory_management.png")


if __name__ == "__main__":
    main()

Example Usage

Run inventory management

python real_time_inventory_management.py

What it produces

Running the file exactly as it ships takes 3.0 s and prints:

python real_time_inventory_management.py

Real-Time Inventory Management
   reorder point  order qty  stockouts  lost units  mean stock
              10         60         21         130        29.5
              25         60          2           3        35.0
              40         60          0           0        49.5
              60         60          0           0        70.3
 
  fewest stockouts at reorder point 40 (0 over 120 periods)
  holding more stock buys fewer stockouts and costs carrying space
  every figure above is derived from 138 logged events, not a stored total
saved real_time_inventory_management.png

Output of real_time_inventory_management.py, produced by running the file. — Written by the run above. If the project stops producing it, the page's figure asset goes missing and check_docs reports it — which is the point of generating it rather than drawing it.

How it fits together

Read from the top: this is what runs when you execute the file, and which function calls which. It is generated from the code, so it cannot drift from it.

diagram Diagram mermaid

  flowchart TD
  RUN(["python real_time_inventory_management.py"])
  InventoryLedger["InventoryLedger
class"]
  ReorderPolicy["ReorderPolicy
class"]
  simulate("simulate")
  main("main")
  RUN --> main
  main --> ReorderPolicy
  main --> simulate
  simulate --> InventoryLedger

Explanation