2nd/10_Wiki/Topics/AI_and_ML/Ecology and Ecosystem Modeling.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-ecology-and-ecosystem-modeling	Ecology and Ecosystem Modeling	10_Wiki/Topics	verified	self	ecosystem modeling agent-based ecology Lotka-Volterra food web population dynamics	none	A	0.92	applied	ecology ecosystem abm lotka-volterra simulation biodiversity food-web		2026-05-10	pending	language framework Python / NetLogo / Mesa NumPy / scipy / Mesa

Ecology and Ecosystem Modeling

매 한 줄

"매 species 매 environment 의 interaction 의 mathematical / computational simulate". 매 Lotka-Volterra (predator-prey), 매 food web, 매 ABM (agent-based). 매 modern: 매 deep learning + 매 climate model coupling.

매 핵심

매 model type

• Differential equation: 매 Lotka-Volterra, SIR-like.
• Matrix model (Leslie): 매 age-structured.
• Individual-based (IBM/ABM): 매 agent.
• Network-based: 매 food web.
• Spatial: 매 PDE / cellular automata.

매 famous

• Lotka-Volterra: 매 predator-prey oscillation.
• NetLogo Wolves-Sheep: 매 ABM textbook.
• Madingley Model: 매 global-scale ecosystem.
• EwE (Ecopath with Ecosim): 매 marine fisheries.

매 응용

1. Conservation: 매 endangered species.
2. Fisheries: 매 stock assessment.
3. Invasive species: 매 spread.
4. Climate adaptation: 매 range shift.
5. Disease ecology: 매 zoonotic.
6. Restoration: 매 rewilding scenario.

매 modern AI

• Species distribution: 매 ML predict.
• Image classification: 매 camera trap.
• Bioacoustic: 매 bird ID.
• Foundation model: 매 GeoCLIP, BioCLIP.

💻 패턴

Lotka-Volterra

import numpy as np
from scipy.integrate import odeint

def lv(state, t, alpha, beta, delta, gamma):
    prey, pred = state
    dprey = alpha * prey - beta * prey * pred
    dpred = delta * prey * pred - gamma * pred
    return [dprey, dpred]

t = np.linspace(0, 50, 1000)
sol = odeint(lv, [10, 5], t, args=(0.5, 0.1, 0.05, 0.5))

Logistic growth (carrying capacity)

def logistic(N, t, r, K):
    return r * N * (1 - N / K)

t = np.linspace(0, 30, 300)
N = odeint(logistic, 5, t, args=(0.5, 100))

Leslie matrix (age-structured)

def leslie_step(pop, fecundity, survival):
    L = np.zeros((len(pop), len(pop)))
    L[0, :] = fecundity
    for i in range(len(pop) - 1):
        L[i + 1, i] = survival[i]
    return L @ pop

# 매 example
pop = np.array([100, 80, 50, 20])
fec = np.array([0, 0.5, 1.5, 0.8])
surv = np.array([0.6, 0.7, 0.5])
for _ in range(20): pop = leslie_step(pop, fec, surv)

Agent-based (Mesa)

from mesa import Agent, Model
from mesa.space import MultiGrid
from mesa.time import RandomActivation

class Sheep(Agent):
    def step(self):
        self.energy -= 1
        if grass_at(self.pos): self.energy += 5
        # 매 move
        x, y = self.random.choice(self.model.grid.get_neighborhood(self.pos, True))
        self.model.grid.move_agent(self, (x, y))
        # 매 reproduce
        if self.energy > 20:
            self.energy /= 2
            self.model.add_sheep(self.pos, self.energy)
        # 매 die
        if self.energy <= 0: self.model.kill(self)

class Wolf(Agent):
    def step(self):
        # 매 hunt sheep
        sheep_nearby = self.model.grid.get_cell_list_contents([self.pos])
        sheep_nearby = [a for a in sheep_nearby if isinstance(a, Sheep)]
        if sheep_nearby:
            self.energy += 20
            self.model.kill(sheep_nearby[0])

class Ecosystem(Model):
    def __init__(self, n_sheep, n_wolves, w, h):
        self.grid = MultiGrid(w, h, torus=True)
        self.schedule = RandomActivation(self)
        for _ in range(n_sheep): self.add_sheep((random_pos), 10)
        for _ in range(n_wolves): self.add_wolf((random_pos), 20)
    def step(self): self.schedule.step()

Food web (network)

import networkx as nx

G = nx.DiGraph()
# 매 edge: prey → predator
G.add_edges_from([
    ('grass', 'rabbit'), ('grass', 'mouse'),
    ('rabbit', 'fox'), ('mouse', 'fox'),
    ('mouse', 'owl'), ('rabbit', 'eagle'),
])

# 매 trophic level
def trophic_level(G, species):
    if G.in_degree(species) == 0: return 1
    preys = list(G.predecessors(species))
    return 1 + np.mean([trophic_level(G, p) for p in preys])

Species distribution model (MaxEnt-style)

from sklearn.ensemble import RandomForestClassifier

def fit_sdm(presences, absences, env_features):
    X = np.vstack([presences, absences])
    y = np.array([1] * len(presences) + [0] * len(absences))
    clf = RandomForestClassifier(n_estimators=200).fit(X, y)
    return clf

def project(clf, future_env_grid):
    return clf.predict_proba(future_env_grid)[:, 1]  # 매 suitability

Spatial spread (cellular automaton)

def spread_step(grid, infected_value=1, p_spread=0.3):
    new_grid = grid.copy()
    H, W = grid.shape
    for i in range(1, H - 1):
        for j in range(1, W - 1):
            if grid[i, j] == 0:
                neighbors = grid[i-1:i+2, j-1:j+2].sum() - grid[i, j]
                if neighbors > 0 and np.random.rand() < 1 - (1 - p_spread) ** neighbors:
                    new_grid[i, j] = infected_value
    return new_grid

Camera trap classifier (BioCLIP)

from transformers import CLIPModel, CLIPProcessor
model = CLIPModel.from_pretrained('imageomics/bioclip')

def classify_animal(image, candidate_species):
    inputs = processor(text=candidate_species, images=image, return_tensors='pt')
    out = model(**inputs)
    return candidate_species[out.logits_per_image.argmax().item()]

Bird sound (BirdNET-style)

def detect_birds(audio, sr=48000, window_s=3):
    # 매 chunked inference
    chunks = chunk(audio, window_s * sr)
    return [birdnet_model.predict(c) for c in chunks]

Sensitivity analysis

from SALib.sample import saltelli
from SALib.analyze import sobol

problem = {
    'num_vars': 4,
    'names': ['alpha', 'beta', 'delta', 'gamma'],
    'bounds': [[0.1, 1], [0.05, 0.2], [0.01, 0.1], [0.1, 1]],
}
param_values = saltelli.sample(problem, 1024)
Y = np.array([simulate(p)[-1, 0] for p in param_values])  # 매 final prey
Si = sobol.analyze(problem, Y)

매 결정 기준

상황	Approach
2-3 species	Lotka-Volterra ODE
Age structure	Leslie matrix
Behavioral	ABM (Mesa / NetLogo)
Network	Food web graph
Range / spatial	SDM + CA
Fisheries	Ecopath / EwE
Camera trap data	BioCLIP / DL

기본값: 매 question-driven — 매 quick population → ODE; 매 behavioral → ABM; 매 modern data → ML SDM.

🔗 Graph

• 부모: Systems-Biology
• 변형: Lotka-Volterra · Food-Web
• Adjacent: Cellular-Automata

🤖 LLM 활용

언제: 매 conservation. 매 invasive species. 매 climate adaptation. 언제 X: 매 hard physics (use mechanistic instead).

❌ 안티패턴

• Ignore stochasticity: 매 small population.
• Single-scale: 매 cross-scale interaction 의 miss.
• Calibrate to single dataset: 매 over-fit.
• No sensitivity analysis: 매 parameter uncertainty.

🧪 검증 / 중복

• Verified (May, Levin Mathematical Ecology).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-04-20	Auto-reinforced
2026-05-08	Phase 1
2026-05-10	Manual cleanup — ODE / ABM / food web / SDM / sensitivity code