Chapter 9: FLUS Adaptive Inertia Model

9.1 Beyond SLEUTH: The FLUS Framework

The Future Land Use Simulation (FLUS) model, developed by Liang et al. (2018), addresses key limitations of traditional CA models like SLEUTH. Its distinguishing feature is the adaptive inertia coefficient—a feedback mechanism that adjusts the “stickiness” of each land use type based on how well the simulation matches the target land use demand.

FLUS combines three components:

• Suitability probability: from an artificial neural network (ANN) or logistic regression
• Adaptive inertia: dynamic adjustment based on conversion success
• Neighbourhood effect: enriched CA transition rules

9.2 Suitability Probability

For each land use type $k$, the suitability probability at cell $p$ is computed from driving factors (distance to roads, elevation, slope, GDP density, population density, etc.) using a trained model:

$$P_{\text{suit}}(p, k) = f_{\text{ANN}}(\mathbf{x}_p; \boldsymbol{\theta}_k), \qquad P_{\text{suit}} \in [0, 1]$$

where $\mathbf{x}_p$ is the feature vector for cell $p$ and$\boldsymbol{\theta}_k$ are the trained parameters for land use type $k$.

9.3 The Adaptive Inertia Coefficient

The adaptive inertia $\Omega_k^t$ for land use type$k$ at iteration$t$ depends on the difference between the current simulated quantity $D_k^{t-1}$ and the target demand $D_k^*$:

$$\Omega_k^t = \begin{cases} \Omega_k^{t-1} & \text{if } |D_k^{t-2} - D_k^*| \leq |D_k^{t-1} - D_k^*| \\[6pt] \Omega_k^{t-1} \cdot \dfrac{D_k^{t-2} - D_k^*}{D_k^{t-1} - D_k^*} & \text{if } (D_k^{t-1} - D_k^*) < (D_k^{t-2} - D_k^*) < 0 \\[6pt] \Omega_k^{t-1} \cdot \dfrac{D_k^* - D_k^{t-2}}{D_k^* - D_k^{t-1}} & \text{if } 0 < (D_k^{t-2} - D_k^*) < (D_k^{t-1} - D_k^*) \\[6pt] \Omega_k^{t-1} & \text{otherwise} \end{cases}$$

Intuition: if land use type$k$ is undersupplied (current < target), its inertia increases, making it “stickier”—harder to convert away from and easier to convert to. If oversupplied, inertia decreases.

This feedback mechanism ensures the simulation converges toward the prescribed land use demand, acting as an implicit optimisation over the transition dynamics.

9.4 Neighbourhood Effect

The neighbourhood effect captures the spatial influence of surrounding land uses. For a$3 \times 3$ Moore neighbourhood:

$$\Omega_{\text{neigh}}(p, k) = \frac{\sum_{q \in \mathcal{N}(p)} \mathbb{1}[c_q = k]}{|\mathcal{N}(p)| - 1} \times w_k$$

where $c_q$ is the current land use of neighbour$q$,$\mathbb{1}[c_q = k]$ is 1 if neighbour$q$ has land use$k$, and$w_k$ is the neighbourhood weight for type$k$.

9.5 Combined Transition Probability

The total probability of cell $p$ converting to land use type $k$ combines all three components:

$$P_{\text{total}}(p, k) = P_{\text{suit}}(p, k) \times \Omega_k^t \times \left(1 + \ln(\Omega_{\text{neigh}}(p, k))\right)$$

Roulette Wheel Selection

At each iteration, each cell that is a candidate for conversion selects a new land use type using roulette wheel (proportional) selection:

$$P(\text{select } k) = \frac{P_{\text{total}}(p, k)}{\sum_{k'} P_{\text{total}}(p, k')}$$

The cell converts to land use $k$ if$P_{\text{total}}(p, k)$ exceeds a random threshold AND the land use demand for $k$ has not yet been met.

9.6 Convergence Properties

The adaptive inertia mechanism acts as a proportional controller that drives the simulation toward the target land use distribution. Define the error:

$$e_k^t = D_k^t - D_k^*$$

The adaptive inertia approximately implements:

$$\Omega_k^{t+1} \approx \Omega_k^t \cdot \frac{e_k^{t-1}}{e_k^t}$$

This ratio-based update ensures rapid convergence when errors are large and fine-tuning when errors are small, similar to a proportional-integral controller in control theory.

9.7 Python: FLUS Simulation

Full FLUS implementation with adaptive inertia, neighbourhood effects, and demand-driven allocation.

FLUS: Adaptive Inertia Land Use Simulation

Python

script.py169 lines

import numpy as np

np.random.seed(42)

# ── FLUS Model: Adaptive Inertia Simulation ──
N_grid = 40
n_types = 3  # 0=undeveloped, 1=residential, 2=commercial
n_iters = 30

# Land use demand targets (number of cells)
demand = {0: 900, 1: 500, 2: 200}  # total = 1600 = 40*40

# Suitability maps (simplified: based on distance to center and random factors)
suit = np.zeros((N_grid, N_grid, n_types))
center = N_grid // 2
for i in range(N_grid):
    for j in range(N_grid):
        d = np.sqrt((i - center)**2 + (j - center)**2)
        suit[i, j, 0] = 0.3 + 0.5 * (d / (N_grid * 0.7))   # undeveloped: higher at edges
        suit[i, j, 1] = 0.6 * np.exp(-d / (N_grid * 0.3))    # residential: high near center
        suit[i, j, 2] = 0.4 * np.exp(-d / (N_grid * 0.15))   # commercial: very central
        # Normalize
        total_s = sum(suit[i, j, :])
        suit[i, j, :] /= total_s

# Initial land use
land = np.zeros((N_grid, N_grid), dtype=int)  # all undeveloped
land[center-3:center+4, center-3:center+4] = 1  # residential core
land[center-1:center+2, center-1:center+2] = 2  # commercial center

# Adaptive inertia coefficients
omega = np.ones(n_types)  # initial inertia = 1 for all types
neigh_weights = np.array([0.5, 1.0, 1.2])  # neighbourhood influence per type

def count_types(land):
    return {k: np.sum(land == k) for k in range(n_types)}

def neighbourhood_effect(land, i, j, k):
    """Fraction of Moore neighbours with land use k."""
    count = 0
    total = 0
    for di in [-1, 0, 1]:
        for dj in [-1, 0, 1]:
            if di == 0 and dj == 0:
                continue
            ni, nj = i + di, j + dj
            if 0 <= ni < N_grid and 0 <= nj < N_grid:
                total += 1
                if land[ni, nj] == k:
                    count += 1
    return (count / total * neigh_weights[k]) if total > 0 else 0.0

print("=" * 72)
print("  FLUS Adaptive Inertia Model")
print("=" * 72)
print(f"  Grid: {N_grid}x{N_grid}, Land use types: {n_types}, Iterations: {n_iters}")
print(f"  Demand: {demand}")
print()

counts_prev = count_types(land)
counts_prev2 = counts_prev.copy()

print(f"  {'Iter':>5} {'Undev':>8} {'Resid':>8} {'Comm':>8} {'Omega_0':>9} {'Omega_1':>9} {'Omega_2':>9} {'Err':>8}")
print("-" * 72)

for it in range(n_iters):
    # Update adaptive inertia
    if it >= 2:
        for k in range(n_types):
            err_prev = counts_prev2[k] - demand[k]
            err_curr = counts_prev[k] - demand[k]
            if abs(err_prev) <= abs(err_curr):
                pass  # keep omega unchanged
            elif err_curr < err_prev < 0:
                omega[k] *= (err_prev / err_curr) if err_curr != 0 else 1.0
            elif 0 < err_prev < err_curr:
                omega[k] *= ((demand[k] - err_prev) / (demand[k] - err_curr)) if (demand[k] - err_curr) != 0 else 1.0
            omega[k] = np.clip(omega[k], 0.1, 5.0)

# Compute combined probability and allocate
    land_new = land.copy()
    conversions = 0

# Identify candidate cells (allow conversion at boundaries)
    for i in range(N_grid):
        for j in range(N_grid):
            current_k = land[i, j]

# Compute P_total for each type
            p_total = np.zeros(n_types)
            for k in range(n_types):
                p_suit = suit[i, j, k]
                omega_neigh = neighbourhood_effect(land, i, j, k)
                neigh_term = 1.0 + np.log(max(omega_neigh, 0.01))
                p_total[k] = p_suit * omega[k] * max(neigh_term, 0.01)

p_total = np.maximum(p_total, 0)
            p_sum = np.sum(p_total)
            if p_sum == 0:
                continue
            p_total /= p_sum

# Roulette wheel: select type with highest combined probability
            selected_k = np.argmax(p_total)

# Only convert if different and random threshold met
            if selected_k != current_k:
                threshold = 0.3 + 0.4 * np.random.random()
                if p_total[selected_k] > threshold:
                    # Check demand not exceeded
                    current_counts = count_types(land_new)
                    if current_counts.get(selected_k, 0) < demand[selected_k] * 1.05:
                        land_new[i, j] = selected_k
                        conversions += 1

counts_prev2 = counts_prev.copy()
    counts_prev = count_types(land_new)
    land = land_new

total_err = sum(abs(counts_prev[k] - demand[k]) for k in range(n_types))

if it % 3 == 0 or it == n_iters - 1:
        print(f"  {it+1:5d} {counts_prev[0]:8d} {counts_prev[1]:8d} {counts_prev[2]:8d} "
              f"{omega[0]:9.3f} {omega[1]:9.3f} {omega[2]:9.3f} {total_err:8d}")

# Final comparison
print()
print("  Final vs Target:")
for k in range(n_types):
    name = ['Undeveloped', 'Residential', 'Commercial'][k]
    actual = counts_prev[k]
    target = demand[k]
    err = actual - target
    pct = abs(err) / target * 100
    print(f"    {name:<14}: actual={actual:5d}, target={target:5d}, error={err:+5d} ({pct:.1f}%)")

print()
print("  Comparison: FLUS vs Standard CA (no adaptive inertia)")
# Run standard CA without adaptive inertia for comparison
land_std = np.zeros((N_grid, N_grid), dtype=int)
land_std[center-3:center+4, center-3:center+4] = 1
land_std[center-1:center+2, center-1:center+2] = 2

for it in range(n_iters):
    land_new_std = land_std.copy()
    for i in range(N_grid):
        for j in range(N_grid):
            p_t = np.zeros(n_types)
            for k in range(n_types):
                ne = neighbourhood_effect(land_std, i, j, k)
                p_t[k] = suit[i,j,k] * max(1.0 + np.log(max(ne, 0.01)), 0.01)
            p_t = np.maximum(p_t, 0)
            p_s = np.sum(p_t)
            if p_s > 0:
                p_t /= p_s
                sel = np.argmax(p_t)
                if sel != land_std[i,j] and p_t[sel] > 0.4:
                    land_new_std[i,j] = sel
    land_std = land_new_std

counts_std = count_types(land_std)
err_flus = sum(abs(counts_prev[k] - demand[k]) for k in range(n_types))
err_std = sum(abs(counts_std[k] - demand[k]) for k in range(n_types))

print(f"    FLUS total absolute error:     {err_flus}")
print(f"    Standard CA total abs error:   {err_std}")
print(f"    Improvement: {(1 - err_flus/max(err_std,1))*100:.1f}%")
print()
print("  Adaptive inertia significantly improves demand matching.")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

9.8 FLUS vs Standard CA: Key Advantages

Feature	Standard CA	FLUS
Demand matching	No guarantee	Adaptive inertia drives convergence
Suitability model	Fixed rules	ANN-based, data-driven
Multiple land uses	Binary (urban/non-urban)	Arbitrary number of types
Feedback	None or ad hoc	Systematic adaptive inertia
Calibration	Brute-force search	ANN training + inertia self-tunes

9.9 Summary & Key Takeaways

• FLUS combines ANN-based suitability, adaptive inertia, and neighbourhood effects
• The adaptive inertia $\Omega_k^t$ adjusts dynamically based on demand-supply mismatch
• Combined probability: $P_{\text{total}} = P_{\text{suit}} \times \Omega_{\text{inertia}} \times (1 + \ln \Omega_{\text{neigh}})$
• Roulette wheel selection allocates cells to land use types proportionally
• FLUS significantly outperforms standard CA in matching prescribed land use demands
• The inertia mechanism acts as a proportional controller, ensuring convergence

← SLEUTH Model Next: Part IV Overview →