ModSim: HS 3

Leg kort het verschil tussen voorwaarts en achterwaarts automatisch afleiden uit en wnr je de ene of de andere zou gebruiken. Voorwaartse automatische differentiatie:

Voorwaartse automatische differentiatie (forward mode)

Bij voorwaartse differentiatie wordt de computational graph van de invoer naar de uitvoer doorlopen, dus in dezelfde volgorde als de oorspronkelijke berekening. Bij elke stap berekent men zowel de functiewaarde als de afgeleide ten opzichte van een gekozen invoervariabele. De afgeleiden worden stap voor stap opgebouwd via de kettingregel.

Kenmerk: één doorloop van het algoritme geeft de afgeleide met betrekking tot één invoervariabele.

Wanneer gebruiken?

Forward mode is het meest efficiënt wanneer een functie weinig invoervariabelen maar veel outputs heeft.
Bijvoorbeeld: een model met enkele parameters waarvan we de oplossing op veel tijdstappen evalueren.

Leg kort het verschil tussen voorwaarts en achterwaarts automatisch afleiden uit en wnr je de ene of de andere zou gebruiken. Achterwaartse automatische differentiatie:

Achterwaartse automatische differentiatie (reverse mode)

Bij achterwaartse differentiatie wordt de computational graph in omgekeerde richting doorlopen: van de uitvoer naar de invoer. Men start met de afgeleide van de output naar zichzelf (die gelijk is aan 1) en gebruikt vervolgens de kettingregel om de afgeleiden naar alle invoervariabelen terug te propageren.

Kenmerk: één achterwaartse doorloop berekent de afgeleiden van de output naar alle invoervariabelen tegelijk.

Wanneer gebruiken?

Reverse mode is het meest efficiënt wanneer een functie veel invoervariabelen maar slechts één output heeft.
Dit komt bijvoorbeeld vaak voor in machine learning, waar een model miljoenen parameters heeft maar slechts één verliesfunctie (loss).

Wat zijn stijve (stiff) differentiaalvgl?

Een stijve differentiaalvergelijking is een differentiaalvergelijking waarvan de oplossing op meerdere zeer verschillende tijdschalen verandert. Dat betekent dat sommige processen in het systeem heel snel verlopen, terwijl andere veel trager evolueren.

Met andere woorden: het systeem bevat snelle en trage dynamica tegelijk.

Een eenvoudig voorbeeld is de vergelijking uit het verbrandingsmodel:

u’(t) = u²-u³

Hier groeit het systeem eerst snel en evolueert daarna trager naar een stabiel evenwicht.

Wnr zou je die stijve DVN kunnen tegenkomen?

Stijve ODE’s komen vaak voor in systemen waar processen met verschillende tijdschalen tegelijk optreden. Typische voorbeelden zijn:

• Biologische systemen
  Bijvoorbeeld: fotosynthese reageert in microseconden terwijl biomassa-opbouw dagen duurt.

• Chemische reacties
  Sommige reacties (zoals radicalenreacties) gebeuren extreem snel, terwijl andere veel trager verlopen.

• Verbrandingsprocessen

• Ecologische of farmacokinetische modellen

• Elektrische circuits met snelle en trage componenten

In zulke systemen veranderen sommige variabelen dus veel sneller dan andere.

Wat is het probleem met stijve DVG? Hoe ga je hier mee om?

Het probleem ontstaat bij de numerieke oplossing van de differentiaalvergelijkingen.

Veel standaardmethoden voor ODE’s, zoals:

• Euler methode

• klassieke Runge–Kutta methoden

zijn expliciete methoden. Deze methoden zijn instabiel bij stijve problemen tenzij men een zeer kleine tijdstap gebruikt.

Dit leidt tot twee grote problemen:

1. Extreem kleine tijdstappen nodig om stabiliteit te garanderen.

2. Zeer lange rekentijd, zelfs wanneer men eigenlijk enkel geïnteresseerd is in de trage dynamiek van het systeem.

Dus zelfs wanneer het snelle gedrag fysisch niet zo belangrijk is op lange termijn, dwingt het de numerieke solver toch om heel kleine stappen te nemen.

→ Hoe ga je om met stijve differentiaalvergelijkingen?

Voor stijve systemen gebruikt men speciale numerieke methoden, namelijk impliciete solvers. Deze zijn stabieler bij stijve problemen en laten grotere tijdstappen toe.

Voorbeelden van zulke methoden zijn:

• Rosenbrock-methoden

• Backward Euler

• BDF-methoden (Backward Differentiation Formulas)

Deze methoden lossen bij elke stap een vergelijking impliciet op, waardoor ze veel stabieler zijn voor systemen met snelle dynamica.

Wat is het verschil tssn een expliciete en impliciete numerieke methode om DVGn op te lossen?

Expliciete methoden:
Deze methoden gebruiken uitsluitend informatie van de huidige tijdstap t_n​ en de bijbehorende oplossingswaarde y(t_n). Ze gebruiken een eindige-differentieschema om de afgeleide y′ in t_n te benaderen. Deze benaderde afgeleide wordt vervolgens samen met y(t_n) ingevuld in een expliciete formule om rechtstreeks de oplossing in de volgende tijdstap te berekenen, y(t_n+1). Voorbeelden van expliciete methoden zijn de methode van Euler en veel Runge–Kutta-methoden.

Impliciete methoden:
In tegenstelling tot expliciete methoden gebruiken impliciete methoden informatie van zowel de huidige als de toekomstige tijdstap. Ze bevatten een vergelijking waarin zowel y(t_n) als y(t_(n+1)) voorkomt (de oplossingswaarde die we juist willen bepalen). Deze vergelijking moet vaak iteratief opgelost worden, bijvoorbeeld met de methode van Newton. Impliciete methoden kunnen betere stabiliteit bieden voor bepaalde soorten differentiaalvergelijkingen, vooral voor stijve problemen (zie Sectie 3.2.4). Toch kunnen ze rekenkundig gezien meer rekenkracht vergen, omdat bij elke stap een impliciete vergelijking moet worden opgelost. Voorbeelden hiervan zijn de achterwaartse Euler-methode en sommige impliciete Runge-Kutta-methoden.

Wat is het verschil tussen “continuous” en “discrete callbacks”? Geef een mogelijke toepassing van elk.

Continuous callbacks worden geactiveerd wanneer een continue conditiefunctie een bepaalde waarde (meestal nul) kruist. De solver detecteert dit punt nauwkeurig door extra berekeningen rond dat moment uit te voeren. Ze worden vaak gebruikt wanneer een toestand een grens bereikt of wanneer een parameter plots verandert afhankelijk van de systeemtoestand.

Toepassing: een stuiterende bal. Wanneer de positie van de bal y=0 bereikt (de vloer), wordt de snelheid omgekeerd en eventueel verkleind om energieverlies te modelleren.

Discrete callbacks worden geactiveerd op vaste tijdstippen of na een bepaald aantal stappen. Ze hangen dus niet af van een continue conditie in de oplossing, maar van vooraf bepaalde momenten.

Toepassing: een bioreactor waarin periodiek substraat wordt toegevoegd, bijvoorbeeld elke vijf uur extra glucose toevoegen om bacteriegroei te stimuleren.

Is het beter om plotse wijzigingen van input/ parameters in je ODE systeem te incorporeren of via een callback af te handelenen? Waarom?

Het is beter om plotse wijzigingen van input of parameters via callbacks af te handelen in plaats van ze rechtstreeks in het ODE-systeem te incorporeren. Dit komt omdat differentiaalvergelijkingen in principe bedoeld zijn om continue en gladde veranderingen te beschrijven, terwijl plotse sprongen juist discontinu zijn en daarom moeilijk correct in de vergelijkingen zelf te verwerken zijn.

Wanneer je dergelijke sprongen toch in het ODE-systeem opneemt, bijvoorbeeld met voorwaarden zoals if-statements, kan dit leiden tot numerieke problemen en onnauwkeurigheden. De solver weet dan namelijk niet exact wanneer de verandering plaatsvindt, wat de betrouwbaarheid van de oplossing vermindert.

Callbacks bieden hiervoor een betere oplossing, omdat de solver specifiek ontworpen is om gebeurtenissen op het juiste moment te detecteren. Bij een continue callback kan de solver bijvoorbeeld nauwkeurig bepalen wanneer een bepaalde toestand een grenswaarde bereikt, en op dat exacte moment de nodige aanpassing uitvoeren. Bij discrete callbacks kunnen veranderingen op vooraf bepaalde tijdstippen worden toegepast.

Daarnaast zorgen callbacks voor een duidelijke scheiding tussen het continue model en de discrete gebeurtenissen, wat het model overzichtelijker en gemakkelijker te begrijpen maakt. Daarom hebben callbacks de voorkeur voor het modelleren van plotse veranderingen in systemen die verder continu gedrag vertonen

Leg in je eigenwoorden uit wat een Wiener proces is. Welke fysische proces modelleert dit? Is dit een “gladde” functie?

Een Wienerproces is een wiskundig model voor een willekeurig proces dat continu in de tijd evolueert, maar waarbij de veranderingen volledig bepaald worden door toeval. In elk klein tijdsinterval wordt er een kleine, normaal verdeelde willekeurige stap toegevoegd, met gemiddelde nul en een variantie die afhangt van de grootte van het tijdsinterval. Bovendien zijn deze stappen onafhankelijk van elkaar, wat betekent dat de toekomstige evolutie niet afhangt van het verleden.

Fysisch modelleert een Wienerproces de Brownse beweging, dat is de grillige, willekeurige beweging van kleine deeltjes in een vloeistof of gas. Deze beweging ontstaat doordat de deeltjes voortdurend botsen met moleculen uit hun omgeving, wat leidt tot onvoorspelbare veranderingen in hun snelheid en richting.

Hoewel een Wienerproces continu is (er zijn geen sprongen), is het geen gladde functie. Dat betekent dat het nergens differentieerbaar is: als je inzoomt op de grafiek, blijft die er altijd “ruw” en grillig uitzien. Daardoor kun je er geen gewone afgeleide van nemen, wat een belangrijk verschil is met klassieke functies in gewone differentiaalvergelijkingen.

Geef de algemene vorm van een SDE. Wat moet je specifieren? Wnr zou je een SDE gebruiken?

De algemene vorm van een stochastische differentiaalvergelijking (SDE) is:

dY(t)=μ(Y(t),t)dt+σ(Y(t),t)dW

Hierbij moet je twee dingen specificeren: de driftterm μ(Y(t),t), die het deterministische gedrag beschrijft, en de diffusieterm σ(Y(t),t), die de sterkte van de ruis bepaalt. Daarnaast moet je ook een beginvoorwaarde geven en het type ruis (meestal een Wienerproces).
Je gebruikt een SDE wanneer je een systeem wil modelleren dat niet volledig deterministisch is, maar onderhevig is aan continue willekeurige fluctuaties, zoals in biologische systemen, financiële markten of chemische processen met ruis.

Geef de algemene vorm van een SDE. Welke belangrijke stochastisch proces is hier relevant? Leg het uit in je eigenwoorden.

De algemene vorm van een SDE is opnieuw:

dY(t)=μ(Y(t),t)dt+σ(Y(t),t)dW

Het belangrijkste stochastische proces hierin is het Wienerproces. Dit is een continu proces dat willekeurige beweging beschrijft waarbij op elk klein tijdsinterval een kleine, normaal verdeelde verstoring wordt toegevoegd. In mijn eigen woorden: het is een model voor een pad dat voortdurend willekeurig “wiebelig” beweegt, zonder vaste richting, zoals een dronken persoon die willekeurig rondwandelt. Dit proces wordt vaak gebruikt om Brownse beweging te modelleren.

Wat is een jump proces/stochastic simulation algorithm (cfr. het Gillespie algoritme)?

Wat is het verschil met SDEs?

Een jump proces, zoals gesimuleerd met het Gillespie-algoritme, is een stochastisch proces waarbij de toestand in discrete sprongen verandert. In plaats van continue evolutie, veranderen de variabelen plots met gehele stappen (bijvoorbeeld +1 of −1 molecuul) op willekeurige tijdstippen.

Het verschil met SDE’s is dat SDE’s continue variabelen en continue ruis gebruiken, terwijl jump processen werken met discrete aantallen en discrete gebeurtenissen.

Wanneer zou je een jump process gebruiken ipv een SDE? Wanneer een SDE? Wanneer een ODE?

Je gebruikt een jump proces wanneer:

• de aantallen klein zijn (bijvoorbeeld tientallen moleculen),

• en individuele gebeurtenissen belangrijk zijn (zoals één reactie of sterfte).

Je gebruikt een SDE wanneer:

• de aantallen groot zijn,

• en ruis als een continue fluctuatie kan worden benaderd.

Je gebruikt een ODE wanneer:

• het systeem deterministisch is,

• en ruis verwaarloosbaar is of niet relevant.

Gegeven een reactie met een kinetiek, geef de distributie en bereken de verwachte tijd tot een reactie-event adhv de propensiteit.

Voor een reactie met propensiteit a(x)a(x)a(x) volgt de tijd tot het volgende reactie-event een exponentiële verdeling met parameter a(x).

De distributie is dus: T∼Exp(a(x)).

De verwachte tijd tot een reactie-event is: E[T]=a(x)1​.

Dit betekent dat hoe groter de propensiteit (dus hoe groter de kans op reactie), hoe korter de gemiddelde wachttijd tot het volgende event.

Leg in je eigen woorden het principe van het Gillespie algoritme uit.

Het Gillespie-algoritme is een methode om een stochastisch systeem met discrete gebeurtenissen exact te simuleren in de tijd. Het principe is dat je telkens bepaalt wanneer de volgende reactie gebeurt en welke reactie dat is.

In mijn eigen woorden werkt het als volgt: je start met een beginsituatie en berekent voor elke mogelijke reactie hoe waarschijnlijk die is (de propensiteit). Vervolgens bepaal je willekeurig hoe lang het duurt tot de volgende reactie, op basis van een exponentiële verdeling met de totale propensiteit. Daarna kies je willekeurig welke reactie plaatsvindt, waarbij reacties met een hogere propensiteit meer kans hebben. Je past het systeem aan volgens die reactie en herhaalt dit proces.

Op die manier bouw je stap voor stap een traject op waarin de toestand van het systeem verandert door afzonderlijke, willekeurige gebeurtenissen.