Agentbaseret simulering i landbrug

Agentbaseret simulering kan være et nyttigt værktøj til skovbrugsplanlægning og landbrugsplanlægning, da det kan hjælpe med at simulere og forstå de komplekse interaktioner mellem systemenheder. Agent-baseret simulering er en metode til kompleks systemdesign og analyse. Metoden implementerer mikroskopisk systemadfærd med agenter, der interagerer med hinanden og med det miljø, de befinder sig i. Agenter har attributter, adfærd – hvoraf nogle er interne, og nogle af dem foregår i form af interaktioner med agenter omkring dem. Denne type modellering bidrager til politikanalyse. Det gør det ved at studere virkningen af adfærdsændringer på systemet som helhed. Den analyserer også påvirkningen som følge af absorption af eksterne påvirkninger. Agent-baseret simuleringer derfor ofte at tage fat på strategiske emner. Denne artikel dækker agentbaseret simulering til plantevækstmodellering. Landbrugs- og skovbrugsplanlægning kan gøre brug af sådanne modeller til prognoser og beslutningstagning.

Eksemplariske anvendelser inden for skovbrug og landbrug

Agentbaseret simulering kan fx modellere vækst og udvikling af træer i en skov og samspillet mellem træerne og miljøet. Modellen kan simulere, hvordan forskellige faktorer, såsom jordbundssammensætning, klima og konkurrence om ressourcer, påvirker de enkelte træers vækst og overlevelse og skovens generelle sundhed. Modellen kan også teste forskellige skovforvaltningsstrategier, såsom udtynding eller rydning, og deres indvirkning på skovens økosystem.

Agent-baseret simulering kan modellere interaktionerne mellem forskellige afgrøder, husdyr og miljøet i et landbrugssystem. Modellen kan simulere, hvordan forskellige faktorer, såsom jordkvalitet, klima og skadedyrsangreb, påvirker væksten og udbyttet af afgrøder og dyrenes sundhed og produktivitet. Modellen kan desuden teste forskellige landbrugsmetoder, såsom sædskifte eller brug af gødning, og deres indvirkning på landbrugssystemet.

Lille plantevækst simuleringsmodel i Python

Den følgende simuleringsmodel i Python demonstrerer agentbaseret modellering og konceptet bag. Ved at bruge, i dette tilfælde, kun NumPy og matplotlib implementerer jeg en simpel agentbaseret plantevækstsimuleringsmodel fra bunden. I denne enkle model vokser træer i gitterceller på et gitterkort, og når de passerer en bestemt alder, formerer de sig i deres omkringliggende tilgængelige celler. Planter dør efter i en bestemt alder. Plantevækst påvirkes også af sollys og allerede opnået plantehøjde.

import numpy as np
import matplotlib.pyplot as plt

# global constants
GRID_SIZE = 10
INITIAL_PLANTS = 50
MAX_PLANT_HEIGHT = 10
MAX_PLANT_LIFETIME = 10
PLANT_REPRODUCTION_PROBABILITY = 0.1
SUNLIGHT_RANGE = (0.0, 1.0)

class Plant:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.height = 1
        self.lifetime = 0

    def grow(self, sunlight):
        if self.height < MAX_PLANT_HEIGHT:
            self.height += sunlight

        self.lifetime += 1

    def reproduce(self):
        if np.random.uniform(0, 1) < PLANT_REPRODUCTION_PROBABILITY:
            return Plant(self.x, self.y)
        else:
            return None

class Grid:
    def __init__(self, size):
        self.size = size
        self.plants = []

        # initialize plants
        for i in range(INITIAL_PLANTS):
            x = np.random.randint(0, self.size)
            y = np.random.randint(0, self.size)
            plant = Plant(x, y)
            self.plants.append(plant)

    def update(self):
        sunlight_map = self.get_sunlight_map()

        # grow existing plants
        for plant in self.plants:
            sunlight = sunlight_map[plant.x, plant.y]
            plant.grow(sunlight)

            # check if plant has reached max lifetime or height
            if plant.lifetime >= MAX_PLANT_LIFETIME or plant.height >= MAX_PLANT_HEIGHT:
                self.plants.remove(plant)
            else:
                # reproduce if possible
                new_plant = plant.reproduce()
                if new_plant is not None:
                    self.plants.append(new_plant)

    def get_sunlight_map(self):
        # generate a random sunlight map for the grid
        return np.random.uniform(SUNLIGHT_RANGE[0], SUNLIGHT_RANGE[1], size=(self.size, self.size))

    def plot(self):
        # create a plot of the grid with the plants
        fig, ax = plt.subplots()
        ax.imshow(self.get_sunlight_map(), cmap='Greens', interpolation='nearest')

        for plant in self.plants:
            ax.plot(plant.y, plant.x, 'bo', markersize=plant.height)

        plt.show()

# create a grid object and plot it
grid = Grid(GRID_SIZE)
grid.plot()

# update the grid and plot it again
for i in range(10):
    grid.update()
    grid.plot()

Dette er en grid-baseret model, og sådan ser den ud efter 1 iteration:

Og her er, hvordan plantehøjden (størrelsen på skalære plots) ser ud efter 10 iterationer:

I et kommende blogindlæg vil jeg vise, hvordan disse typer modeller nemt implementeres med mit eget abm_framework- bibliotek. Du kan læse mere om biblioteket her:

Link : Agentbaseret simuleringsramme i Python
Link : ABM framework til simulering i Python

Større modeller vil tage mange flere og flere gennemtænkte egenskaber og adfærdsmodeller ind, men implementere dem ud fra det samme eller lignende koncept. For eksempel sygdomsudbrud og sygdomsspredning, forskellige plantearter med forskellig modstand mod sygdomsspredning. Eller virkningen af tørre vs. våde somre kunne analyseres med en agent-baseret simuleringsmodel, der ligner denne. Jordkvalitet eller overbelægning ville være nogle flere eksempler på mekanismer, der kunne implementeres i en sådan model for at forstå deres indvirkning.

Det er vigtigt at forstå, at en god model i dette tilfælde ikke nødvendigvis er en model med tusindvis af attributter, men en model- og scenariedefinition, der effektivt besvarer et defineret forskningsspørgsmål eller analysemål. F.eks. har “adfærd X” en væsentlig indflydelse på “KPI Y” .

Indhold relateret til agentbaseret simulering i skovbrug

De følgende artikler vil tage dig videre i din forståelse af agentbaseret simulering og dens applikationer. De inkluderer også nogle eksempler, som jeg implementerede med abm_framework :