EcoVal Ändringslogg v0.5.0

Så är beräkningarna byggda, del 1: grunderna och de anpassade modellerna

Det här är utvecklarens bild av hur EcoVal räknar. docs/calculations.md (och dess syskon för vatten och stad) förklarar vad varje tal betyder och var indata kommer ifrån. Det här dokumentet förklarar hur talet tas fram i koden: först formeln, sedan C#-koden som räknar ut den, sedan hur delarna hänger ihop.

Del 1 tar upp två saker:

  1. Grunderna som alla beräkningar står på: att göra om en ritad yta till pixlar, att summera raster, och typerna som bär ett resultat (intervall, säkerhetsnivåer, tillgänglighet).
  2. Varje ställe där en modell anpassas till data: vilken sorts anpassning det är, hur den tränas, var resultatet sparas och hur API:et använder det.

Del 2 till 6 (skog, vatten, stad, startsidans kalkylator) står i README.md.

Alla sökvägar utgår från backend/. Kodutdragen är kopierade från källkoden och förkortade; // … visar var något är utelämnat. Koden och dess kommentarer står kvar på engelska.

Innehåll


1. Formen på varje beräkning

Alla resultat går samma väg. Endpointen sköter in- och utläsningen (läser raster och databasen) och lämnar sedan vanliga värden till en kalkylator som är en ren funktion: samma indata ger alltid samma utdata, och inget i den rör en fil eller en databas.

flowchart LR
    A["Webbläsaren<br/>GeoJSON-polygon, WGS84"] --> B["PolygonReader<br/>kontrollera, projicera om till SWEREF 99 TM"]
    B --> C["Lookups och rasterläsare<br/>(I/O: PostGIS, GeoTIFF)"]
    O["Options-klasser<br/>(parametrar med källor)"] --> D
    C --> D["Kalkylator<br/>(rena statiska metoder)"]
    D --> E["Kontraktsposter<br/>ValueRange, nivåer, koder"]
    E --> F["JSON-svar<br/>(OpenAPI-kontraktet)"]

Uppdelningen spelar roll av tre skäl:

  • Tester. En kalkylator kan testas med handskrivna indata och handräknade förväntade värden, utan rasterfiler på disken.
  • Återanvändning. EcoVal.Calibration anropar samma kalkylatormetoder som API:et. En anpassad parameter är alltså anpassad mot exakt den kod som sedan använder den.
  • Spårbarhet. Varje parameter ligger i en options-klass med en kommentar som anger källan, så svaret på "var kommer 1,5 km ifrån?" är ett "go to definition" bort.

En typisk kalkylatorsignatur visar mönstret. All data kommer in som argument, parametrarna som options:

// EcoVal.Api/Features/Forest/Recreation/RecreationCalculator.cs
public static double[] EverydayShares(
    double forestHectares,
    IReadOnlyDictionary<(double X, double Y), double> polygonForest,
    IReadOnlyList<ForestSquare> forest,
    IReadOnlyList<PopulationNear> population,
    double decayKm,
    RecreationOptions options)

2. Från ritad yta till pixlar

2.1 Läsa och projicera om polygonen

Webbläsaren skickar koordinater som longitud och latitud (WGS84). Ytor och avstånd går inte att räkna i grader, så första steget är att projicera om till SWEREF 99 TM (EPSG:3006), där en enhet är en meter.

PolygonReader.Read (EcoVal.Api/Spatial/PolygonReader.cs) kontrollerar indata i tur och ordning och ger det första felet tillbaka som en stabil felkod, aldrig som en mening:

if (ring[0][0] != ring[^1][0] || ring[0][1] != ring[^1][1])
{
    return PolygonReadResult.Invalid(PolygonErrors.RingNotClosed, "Each ring must end at its starting position.");
}
if (ring.Any(p => p[0] is < MinLongitude or > MaxLongitude || p[1] is < MinLatitude or > MaxLatitude))
{
    return PolygonReadResult.Invalid(PolygonErrors.OutsideSweden, "The polygon must lie within Sweden.");
}
// …
var geometry = projection.ProjectPolygon(rings);
var validity = new IsValidOp(geometry).ValidationError;

Själva projektionen är en transversal Mercator-transformation som biblioteket ProjNET gör (EcoVal.Api/Spatial/Sweref99Projection.cs); EcoVal anger bara projektionens definition (medelmeridian 15°, skalfaktor 0,9996, falsk östkoordinat 500 000 m). Geometrioperationerna (giltighet, skärning, yta) kommer från NetTopologySuite.

2.2 Zonstatistik: summera ett raster innanför polygonen

De flesta skogstal börjar som ett raster: ett rutnät av 10 m-pixlar där varje pixel har ett värde, till exempel virkesförrådet i m³sk per hektar. "Zonstatistik" betyder att sammanfatta pixlarna innanför en zon, här polygonen.

Formeln. Låt pixel pp ha värdet vpv_p, och låt sp∈[0,1]s_p \in [0, 1] vara den andel av pixelns yta som ligger innanför polygonen. Pixlar utan data hålls utanför summorna och räknas för sig.

S=∑p ∈ giltigasp vpN=∑p ∈ giltigaspvˉ=SNS = \sum_{p \,\in\, \text{giltiga}} s_p \, v_p \qquad N = \sum_{p \,\in\, \text{giltiga}} s_p \qquad \bar{v} = \frac{S}{N}

För ett raster som innehåller en storhet per hektar är totalen över polygonen summan gånger en pixels yta i hektar, där ℓ\ell är pixelstorleken i meter:

total=S⋅ℓ210 000\text{total} = S \cdot \frac{\ell^2}{10\,000}

Med 10 m-pixlar är varje pixel 0,01 ha, så en pixel som visar 200 m³sk/ha och ligger helt innanför bidrar med 2 m³sk.

Så räknas en pixel på gränsen

Implementationen är ZonalStatistics.Compute (EcoVal.Api/Spatial/Rasters/ZonalStatistics.cs). Den har tre steg:

var grid = PixelGrid.Of(tiles);                                  // the pixel grid all tiles share
var window = grid.WindowCovering(polygon.EnvelopeInternal);      // the pixel rectangle around the polygon
var pixels = Mosaic(tiles, grid, window, noData);                // read that rectangle into one short[]
return Summarise(pixels, grid, window, polygon, noData);         // weight and sum
  1. Mosaik. Ett raster kommer som många filer (tiles). ReadMosaic läser fönstret ur varje fil till en enda array. Där länsfiler överlappar vinner den första filen som har data för pixeln, så inget räknas två gånger.

  2. Täckning. CoverageCells räknar ut sps_p för varje pixel. Att räkna en geometrisk skärning för varje pixel vore långsamt, så den använder två knep:

    • Först märks de pixlar som gränsen går igenom (BoundaryPixels). Bara de får en riktig skärning: polygon.Intersection(box).Area / pixelArea.
    • Alla andra pixlar ligger helt innanför eller helt utanför. En svepande linje avgör vilket: går man från väst till öst längs radens mittlinje växlar tillståndet mellan utanför och innanför varje gång linjen korsar gränsen (jämn–udda-regeln).

    Kostnaden växer därför med gränsens längd, inte med polygonens yta.

  3. Summering. Loopen är formeln ovan, nästan symbol för symbol:

double sum = 0, valid = 0, noDataWeight = 0, zeroWeight = 0;
foreach (var cell in Coverage(grid, window, polygon))
{
    var value = pixels[cell.Index];
    if (value == noData)
    {
        noDataWeight += cell.Share;
        continue;
    }
    // …
    sum += value * cell.Share;      // S = Σ s_p · v_p
    valid += cell.Share;            // N = Σ s_p
}
return new ZonalResult(sum, valid, noDataWeight, zeroWeight, grid.PixelSize);

ZonalResult visar sedan de härledda talen som egenskaper, så anroparna aldrig behöver upprepa räkningen:

public double PixelAreaHectares => PixelSize * PixelSize / 10_000;
public double TotalOfPerHectareValue => Sum * PixelAreaHectares;
public double Mean => ValidPixels > 0 ? Sum / ValidPixels : 0;
public double NoDataShare => ValidPixels + NoDataPixels > 0 ? NoDataPixels / (ValidPixels + NoDataPixels) : 1;

Dela läsningar inom en förfrågan. En värdering läser samma fönster för flera lager och i flera steg. RasterReadScope (EcoVal.Api/Spatial/Rasters/RasterReadScope.cs) är en omgivande cache som hålls i en AsyncLocal: innanför using var reads = RasterReadScope.Begin(); avkodas varje lagers fönster en gång och täckningen räknas en gång. Utanför ett scope (tester, kalibrering) görs varje läsning på nytt.

2.3 Klassytor: räkna efter pixelns mittpunkt, med stickprov

Vissa raster innehåller klasser, inte storheter (till exempel SLU:s markfuktighetskarta med 2 m-pixlar: torr, frisk, fuktig, blöt). Frågan är "hur många hektar av varje klass?", och en polygon på 10 000 ha rymmer 25 miljoner 2 m-pixlar. ClassAreas (EcoVal.Api/Spatial/Rasters/ClassAreas.cs) gör därför två saker annorlunda än ZonalStatistics: en pixel räknas hel om dess mittpunkt ligger innanför polygonen, och över en gräns läses bara var nn:te rad och kolumn.

Formeln. Med ett fönster på W×HW \times H pixlar och en budget på MM stickprov blir steget

n=max⁡ ⁣(1, ⌈W⋅HM⌉)n = \max\!\left(1,\ \left\lceil \sqrt{\frac{W \cdot H}{M}} \right\rceil\right)

och varje stickprov står för n×nn \times n pixlar, så ytan av klass kk är

Ak=∣{stickprov med klass k}∣⋅(n ℓ)210 000 haA_k = \bigl|\{\text{stickprov med klass } k\}\bigr| \cdot \frac{(n\,\ell)^2}{10\,000}\ \text{ha}
var pixels = (double)window.Width * window.Height;
var step = Math.Max(1, (int)Math.Ceiling(Math.Sqrt(pixels / maxSamples)));
var spacing = step * grid.PixelSize;
var sampleHectares = spacing * spacing / 10_000;

Det här är ett systematiskt stickprov: resultatet är en skattning, och ClassCount.SpacingMetres talar om för anroparen hur grovt det var.

2.4 Kilometerrutnätet

Befolkningen (SCB) publiceras per 1 km-ruta, så modellerna som handlar om människor (besök, fiskedagar) arbetar på ett 1 km-rutnät som ligger jäms med SWEREF 99 TM:s origo. SquareGrid.Split (EcoVal.Api/Spatial/SquareGrid.cs) delar en geometri i dess delar per ruta, var och en med sina hektar och rutans mittpunkt. Avstånden i de modellerna mäts sedan mellan rutornas mittpunkter.


3. Typerna som bär ett resultat

3.1 ValueRange: lågt, centralt, högt

Inget resultat är ett enda tal. Varje beräknat värde är tre: ett lågt, ett centralt och ett högt fall (EcoVal.Api/Ranges.cs):

public sealed record ValueRange(double Low, double Central, double High)
{
    public static ValueRange Spanning(double fromLow, double central, double fromHigh, int digits = 1) =>
        new(
            Math.Round(Math.Min(Math.Min(fromLow, fromHigh), central), digits),
            Math.Round(central, digits),
            Math.Round(Math.Max(Math.Max(fromLow, fromHigh), central), digits));
}

Intervallet är inget statistiskt konfidensintervall. Det byggs genom att köra samma formel tre gånger, med det låga, centrala och höga värdet på varje osäker parameter (ParameterRange). När en formel multiplicerar flera osäkra faktorer multiplicerar det låga fallet de låga värdena och det höga fallet de höga:

yla˚g=∏ixi,la˚gycentral=∏ixi,centralyho¨g=∏ixi,ho¨gy_{\text{låg}} = \prod_i x_{i,\text{låg}} \qquad y_{\text{central}} = \prod_i x_{i,\text{central}} \qquad y_{\text{hög}} = \prod_i x_{i,\text{hög}}

Spanning finns för att en parameter kan trycka resultatet åt båda håll; den tar det minsta och största av de tre resultaten som lågt och högt, och låter det centrala stå som det räknades.

3.2 Tier: hur säkert ett tal är

Varje avsnitt i ett resultat bär en säkerhetsnivå som en kod (EcoVal.Api/Tiers.cs): measured (räknat eller karterat på platsen), modelled (modellerat från data om platsen) eller borrowed (en faktor eller ett pris från en studie någon annanstans). Ett resultat är aldrig säkrare än sin svagaste indata:

niva˚(resultat)=max⁡i rang(niva˚i),rang: measured=0, modelled=1, borrowed=2\text{nivå}(\text{resultat}) = \max_i \ \text{rang}(\text{nivå}_i), \qquad \text{rang: measured} = 0,\ \text{modelled} = 1,\ \text{borrowed} = 2
public static SectionTiers Priced(string quantity, string price) => new(quantity, Tier.Weakest(quantity, price));

3.3 Available<T>: ett värde, eller skälet till att det saknas

Saknade data är inget fel. Ett avsnitt har antingen ett värde eller en kod som säger varför inte, modellerat som en union i C# 15 (EcoVal.Api/Available.cs):

public union Available<T>(T, Unavailable)
    where T : class
{
    public T? ValueOrNull => Value as T;
    public string? ReasonOrNull => (Value as Unavailable)?.Reason;
    public void Deconstruct(out T? value, out string? reason) => (value, reason) = (ValueOrNull, ReasonOrNull);
}

En kalkylator skriver return new Unavailable(UnavailableReasons.NoForestData); eller return value;, och endpointen plockar isär den till svarets två fält: var (timber, timberUnavailable) = ….

3.4 Options: parametrar är data

Modellparametrar är aldrig konstanter inne i en formel. De är egenskaper på en options-klass som binds från konfigurationen (builder.Services.AddOptions<ValuationOptions>().BindConfiguration(ValuationOptions.Section)), och standardvärdet i klassen är det dokumenterade värdet, med källan i XML-kommentaren:

// EcoVal.Api/Features/Forest/Recreation/RecreationOptions.cs
/// <summary>
/// Distance d₀ in w(d) = e^(−d/d₀), the weight a forest at distance d gets in where people go. In Friluftsliv 2018
/// (table 4.1) visits to the nearest nature area fall from about 180 a year within 100 m to about 55 at 0.5–1 km
/// and 33 at 1–3 km; an exponential through those points has d₀ ≈ 1.1–1.6 km. …
/// </summary>
public ParameterRange DecayKm { get; set; } = new(1, 1.5, 3);

Det är också här de anpassade parametrarna hamnar, som avsnitt 6 visar.


4. Vilken sorts regression använder EcoVal?

Kort svar: klassisk statistik och kalibrering, skriven för hand i C#. Inget maskininlärningsbibliotek, inget neuralt nätverk, ingen modellfil. Projekten refererar varken ML.NET, Math.NET, ONNX eller något liknande paket; varje anpassning är några tiotal rader aritmetik som går att läsa.

"Att anpassa en modell" förekommer i fyra former. De skiljer sig i hur de bästa parametrarna hittas:

Form Hur parametrarna hittas Var i EcoVal
Statistisk regression, sluten form En formel ger den bästa linjen direkt (minsta kvadratmetoden) Vattendragets bredd från avrinningsområdets yta
Statistisk regression, iterativ Upprepade Newton-steg tills skattningen slutar röra sig (logistisk regression) Kantarellens habitatmodell
Kalibrering med rutnätssökning Pröva varje kombination på ett rutnät av kandidatvärden, behåll den med minst fel Utflykter, turism, fiskedagar
Empiriska kvoter och kvantiler Dela en räknad total med en uppmätt storhet; ta medianer och percentiler Laxsmolt per km, havsöringens tätheter, formhöjd

Är något av det maskininlärning? Kantarellmodellen ligger närmast: logistisk regression är också en vanlig klassificerare inom maskininlärning, och den utvärderas på maskininlärningens sätt, på data som hållits undan från träningen. Men det är en statistisk modell med 13 parametrar och standardfel, ingen inlärd svart låda, och appen använder den inte (avsnitt 6.7). Allt annat är kalibrering: en modell vars form bestäms genom resonemang, med en till tre fria parametrar som ställs in så att modellen stämmer med räknade data.

Anpassningarna skiljer sig också i när de körs och var resultatet finns:

flowchart TB
    subgraph offline ["I förväg: EcoVal.Calibration, startas för hand"]
        C1["Räknade data<br/>(besöksräkningar, enkäter, fynd från GBIF)"] --> C2["Anpassning: rutnätssökning eller regression"]
        C2 --> C3["Rapport i data/calibration/*.md"]
        C3 -->|"en utvecklare kopierar värdena"| C4["Standardvärden i options-klassen<br/>(källkod, med kommentar)"]
    end
    subgraph runtime ["Vid körning: EcoVal.Api, första förfrågan som behöver den"]
        R1["Databastabeller<br/>(elfiskelokaler, vattendragsnätet)"] --> R2["Anpassning: minsta kvadrat, kvantiler, kvoter"]
        R2 --> R3["Singleton i minnet<br/>tills API:et startas om"]
    end
    C4 --> U["Kalkylatorerna använder värdena vid varje förfrågan"]
    R3 --> U

Två följder som är bra att känna till:

  • Anpassningar som görs i förväg uppdaterar inte sig själva. Nya data ändrar ingenting förrän någon kör kalibreringen igen och kopierar de nya värdena till options-klassen. Kommentaren på inställningen anger anpassningens datum.
  • Anpassningar vid körning följer datat. En ny inläsning av elfisken ändrar breddmodellen nästa gång API:et startar. De aktuella värdena syns alltid på /api/water/sea-trout-calibration och /api/water/salmon-calibration.
Anpassning Sort När Sparas i Används av
Vattendragets bredd Minsta kvadrat på log–log API, första användning singleton SeaTroutModel Damm: havsöringens livsmiljö
Havsöringens täthetsklasser Kvantiler per grupp API, första användning singleton SeaTroutModel Damm: havsöringens livsmiljö
Smolt per öringunge Kvoter, median API, första användning singleton SeaTroutModel Damm: havsöringssmolt
Laxsmolt per km Kvoter, regionala kvantiler API, första användning singleton SalmonCalibrationSource Damm: laxsmolt
Utflykter: s, d₁, γ Rutnätssökning I förväg RecreationOptions.Excursion Skog: friluftsliv
Turism: α, d_w, vikter Rutnätssökning + endimensionell minimering I förväg TourismOptions Skog: friluftsliv
Turism: q Rutnätssökning I förväg TourismOptions (kvar som uppskattningar) Skog: friluftsliv
Fiskedagar: d₁, β Rutnätssökning, viktad minsta kvadrat I förväg LakeOptions.FishingByPeople Vatten: sjö
Formhöjd efter ålder Klassvis kvot I förväg CalculatorOptions…FormHeightByAge Startsidans kalkylator
Råvattnets trend i en dricksvattentäkt Sens lutning med Mann–Kendalls test (en icke-parametrisk trendskattning och ett test) API, vid varje förfrågan Sparas inte Vatten: dricksvatten (del 5, avsnitt 5)
Tillväxtmodellen: produktionsnivå, avgång, golv för gammal skog Rutnätssökning, minsta kvadrat I förväg, i ett Python-skript (scripts/review/growth/fit-mortality.py) GrowthOptions Skog: tillväxt och kol (del 2, avsnitt 7.7)
Kantarellens habitat Logistisk regression med ridge-straff I förväg Bara rapporten Används inte

5. Anpassningar som API:et gör vid körning

Alla tre ligger i EcoVal.Api/Features/Water/Dam/. De byggs en gång, vid den första förfrågan som behöver dem, av en singleton-klass ("source") som skyddar bygget med en SemaphoreSlim, så att två samtidiga första förfrågningar inte bygger den var för sig:

// SeaTroutModel.cs
public async Task<SeaTroutModel> GetAsync(CancellationToken cancellationToken)
{
    if (_model is { } model)
    {
        return model;                        // the common path: already built
    }
    var network = await networks.GetAsync(cancellationToken);
    await _lock.WaitAsync(cancellationToken);
    try
    {
        if (_model is null)                  // checked again inside the lock
        {
            // … load the sites from the database …
            _model = new SeaTroutModel(network, sites, options.Value);
        }
        return _model;
    }
    finally
    {
        _lock.Release();
    }
}

5.1 Vattendragets bredd: minsta kvadratmetoden på log–log-skala

Vad den är till för. Öringungar räknas per 100 m² vattendrag, så för att veta hur många en sträcka rymmer behöver vi dess bredd. Bredden är bara mätt vid elfiskelokalerna; överallt annars förutsägs den från hur mycket mark som avvattnas genom punkten.

Sorts anpassning: statistisk regression (enkel linjär regression, minsta kvadratmetoden), som API:et självt tränar från tabellen electrofishing_surveys.

Modellen. Bredden växer med avrinningsområdets yta som en potenslag, vilket blir en rät linje när båda logaritmeras:

log⁡10w=a+b log⁡10A⟺w=10a⋅Ab\log_{10} w = a + b \, \log_{10} A \qquad\Longleftrightarrow\qquad w = 10^{a} \cdot A^{b}

där ww är den vattentäckta bredden i meter och AA ytan som avvattnas genom punkten i km².

Anpassningen. Med xi=log⁡10Aix_i = \log_{10} A_i och yi=log⁡10wiy_i = \log_{10} w_i över de nn lokalerna har minsta kvadratmetoden en sluten lösning:

Sxx=∑i(xi−xˉ)2Sxy=∑i(xi−xˉ)(yi−yˉ)Syy=∑i(yi−yˉ)2S_{xx} = \sum_i (x_i - \bar{x})^2 \qquad S_{xy} = \sum_i (x_i - \bar{x})(y_i - \bar{y}) \qquad S_{yy} = \sum_i (y_i - \bar{y})^2 b=SxySxxa=yˉ−b xˉR2=Sxy2Sxx Syyb = \frac{S_{xy}}{S_{xx}} \qquad a = \bar{y} - b\,\bar{x} \qquad R^2 = \frac{S_{xy}^2}{S_{xx}\,S_{yy}}

R2R^2 är den andel av variationen i log⁡w\log w som linjen förklarar.

Implementationen är den privata metoden SeaTroutModel.Fit, en rak avskrift:

private static WidthModel? Fit(List<(double X, double Y)> points)
{
    if (points.Count < 10)
    {
        return null;                                    // too few sites: no model
    }
    var meanX = points.Average(point => point.X);
    var meanY = points.Average(point => point.Y);
    var sxx = points.Sum(point => (point.X - meanX) * (point.X - meanX));
    var sxy = points.Sum(point => (point.X - meanX) * (point.Y - meanY));
    var syy = points.Sum(point => (point.Y - meanY) * (point.Y - meanY));
    var slope = sxy / sxx;
    return new WidthModel(
        Math.Round(meanY - slope * meanX, 4),           // a
        Math.Round(slope, 4),                           // b
        points.Count,
        Math.Round(syy > 0 ? sxy * sxy / (sxx * syy) : 0, 3));   // R²
}

Träningsdatat förbereds i konstruktorn. Tre val är värda att lägga märke till:

Width = Fit(sites
    .Where(site => site.Width is > 0 && site.Snap <= options.WidthFitMaxSnapMetres)
    .Select(site => (Area: network.AreaAt(site.Position), Width: site.Width!.Value))
    .Where(pair => pair.Area is > 0)
    .Select(pair => (Math.Log10(pair.Area!.Value), Math.Log10(pair.Width)))
    .ToList());
  • En lokal som fiskats flera gånger går in en gång, med medianen av sina bredder (räknas strax ovanför den här koden), så att flitigt fiskade lokaler inte dominerar.
  • Bara lokaler inom 30 m från nätets linje används (WidthFitMaxSnapMetres). En lokal i en liten bäck som nätet saknar skulle annars fästas vid den stora ån intill och lära modellen att stora åar är smala.
  • Logaritmerna tas före anpassningen, så regressionen minimerar relativa fel, inte fel i meter.

Använda modellen. WidthModel.Width tar bort logaritmen, och SegmentValues håller resultatet inom ett rimligt intervall och sparar det per vattendragssegment:

public double Width(double areaKm2) => Math.Pow(10, Intercept + Slope * Math.Log10(Math.Max(areaKm2, 0.01)));

var width = Math.Clamp(
    Width is { } model && network.AreaAtOutlet(id) is > 0 and var area ? model.Width(area) : options.MinWidthMetres,
    options.MinWidthMetres,      // 1 m
    options.MaxWidthMetres);     // 150 m
Vattendragets bredd från avrinningsområdets yta

När detta skrivs är anpassningen log⁡10w=0,39+0,16log⁡10A\log_{10} w = 0{,}39 + 0{,}16 \log_{10} A från 4 126 lokaler, med R2=0,17R^2 = 0{,}17 (docs/calculations-water.md). Ett R2R^2 på 0,17 är svagt: avrinningsområdets yta förklarar bara ungefär en sjättedel av variationen i bredd. Modellen ger en rimlig typisk bredd, inte en bra bredd för ett enskilt vattendrag. Det duger här eftersom bredderna summeras över många segment, där felen delvis tar ut varandra.

5.2 Havsöringens tätheter och smolt per öringunge: kvantiler och kvoter

Sorts anpassning: empirisk statistik, inte regression. Inget optimeras; observerade värden grupperas och sammanfattas.

Täthetsklasser. De lokaler som havsöring når fritt i dag (inget hinder på vägen till havet) grupperas efter vattendistrikt och breddklass (gränser vid 2, 4, 8, 16 och 32 m). Varje grupps täthet är 25:e percentilen, medianen och 75:e percentilen av dess lokaler, som blir lågt, centralt och högt i ett ValueRange.

Kvantilen som används genomgående interpolerar linjärt mellan grannvärden. För sorterade värden x0≤⋯≤xn−1x_0 \le \dots \le x_{n-1} och en kvantil qq:

t=q (n−1)Q(q)=x⌊t⌋+(t−⌊t⌋)(x⌊t⌋+1−x⌊t⌋)t = q\,(n-1) \qquad Q(q) = x_{\lfloor t \rfloor} + \bigl(t - \lfloor t \rfloor\bigr)\bigl(x_{\lfloor t \rfloor + 1} - x_{\lfloor t \rfloor}\bigr)
// SalmonCalibration.cs
public static double Quantile(IReadOnlyList<double> sorted, double q)
{
    var position = q * (sorted.Count - 1);
    var below = (int)Math.Floor(position);
    var above = Math.Min(below + 1, sorted.Count - 1);
    return sorted[below] + (sorted[above] - sorted[below]) * (position - below);
}

En grupp med färre än MinSitesPerClass (10) lokaler är för tunn att lita på, så DensityFor faller tillbaka på samma breddklass över hela Sverige och anger som en kod vilken källa den använde (district eller national).

Öringungar i en sträcka. För en sträcka av delar jj med längd LjL_j (m), modellerad bredd wjw_j (m) och klassens täthet ρj\rho_j (öringungar per 100 m²):

Y=∑jLj⋅wj⋅ρj100Y = \sum_j L_j \cdot w_j \cdot \frac{\rho_j}{100}
public (double YoungTrout, double AreaM2) Habitat(HabitatStretch stretch)
{
    var (young, area) = (0.0, 0.0);
    foreach (var piece in stretch.Pieces)
    {
        var length = (piece.To - piece.From) * (network.Segment(piece.SegmentId)?.LengthMetres ?? 0);
        var (width, perMetre) = SegmentValues(piece.SegmentId);   // perMetre = width × density / 100
        young += length * perMetre;
        area += length * width;
    }
    return (young, area);
}

Smolt per öringunge. I tre åar räknas smolten som vandrar ut mot havet i en fälla. För varje sådan å rr räknar modellen ut YrY_r, de öringungar dess egen metod förutsäger ovanför fällan, och delar varje års räkning med det:

kr,t=smoltr,tYrk_{r,t} = \frac{\text{smolt}_{r,t}}{Y_r}

Värdet som används överallt är medianen över åarna av varje ås median, med det lägsta och högsta enskilda året som intervall:

kcentral=median⁡r(median⁡t kr,t)kla˚g=min⁡r,tkr,tkho¨g=max⁡r,tkr,tk_{\text{central}} = \operatorname{median}_r \bigl(\operatorname{median}_t\, k_{r,t}\bigr) \qquad k_{\text{låg}} = \min_{r,t} k_{r,t} \qquad k_{\text{hög}} = \max_{r,t} k_{r,t}
var ratios = young > 0 ? river.Smolts.Values.Select(smolts => smolts / young).Order().ToList() : [];

Det här är en kalibrering med kvot: faktorn kk tar upp allt som täthetsmodellen i genomsnitt har fel om, så att modellen återger de räknade åarna per konstruktion. Den är ärlig med att det bara rör sig om tre åar: endpointen listar varje å med sin egen kvot.

5.3 Laxsmolt per km: en kvot, med regionala kvantiler

Sorts anpassning: kalibrering med kvot. ICES publicerar varje vild laxälvs potentiella smoltproduktion (PSPC). EcoVal vandrar älven i sitt eget nät, med samma regel för livsmiljö som sträckan uppströms en damm vandras med, och delar:

dr=PSPCrLrsmolt per kmd_r = \frac{\text{PSPC}_r}{L_r}\quad \text{smolt per km}
// SalmonCalibration.cs
var habitat = network.Habitat(mouth, new HashSet<int>(), options.MinUpstreamAreaKm2);
var km = habitat.LengthMetres / 1000;
var pspc = river.PspcThousands!.Value * 1000;
// …
new ValueRange(
    Math.Round((river.PspcLowThousands ?? river.PspcThousands.Value) * 1000 / km),
    Math.Round(pspc / km),
    Math.Round((river.PspcHighThousands ?? river.PspcThousands.Value) * 1000 / km))

Poängen med att använda samma vandring är att ett systematiskt fel i hur EcoVal mäter livsmiljöns längd finns både i kalibreringen och i förutsägelsen, och tar ut sig.

En damms älv får sedan en täthet enligt en regel i två steg i SalmonCalibration.Density: den egna älvens värde om älven är kalibrerad, annars medianen av regionens älvar med 10:e och 90:e percentilen som intervall:

return (new ValueRange(
        Math.Round(Quantile(region, 0.1)),
        Math.Round(Quantile(region, 0.5)),
        Math.Round(Quantile(region, 0.9))),
    SalmonDensitySources.RegionMedian,
    region.Count);

6. Anpassningar som görs i förväg av EcoVal.Calibration

EcoVal.Calibration är ett konsolprogram som står i AppHost med uttrycklig start. Program.cs registrerar API:ets egna tjänster (builder.AddForestry(), RecreationLookups, options-klasserna) och kör de modeller som anges i Calibration__Models, och skriver en Markdown-rapport per modell till data/calibration/.

Fyra av anpassningarna ställer in samma modellfamilj, så den modellen kommer först.

6.1 Modellen som kalibreras: fördela besök efter avstånd

Tanken. Människorna i varje 1 km-befolkningsruta gör ett fast antal naturbesök per år. Besöken fördelas på all skog inom räckhåll: mer till skog som ligger nära, mindre till skog som ligger långt bort, och andelarna summerar alltid till ett. En skog omgiven av människor och lite annan skog får många besök; en skog bland ändlös skog får få. Modeller av den här formen kallas gravitationsmodeller eller rumsliga interaktionsmodeller.

Avståndsvikten. Skog på avståndet dd från ett hem får vikten

w(d)={exp⁡ ⁣(−max⁡(d, dgolv)d0)d≤dra¨ckvidd0d>dra¨ckviddw(d) = \begin{cases} \exp\!\left(-\dfrac{\max(d,\ d_{\text{golv}})}{d_0}\right) & d \le d_{\text{räckvidd}} \\[2ex] 0 & d > d_{\text{räckvidd}} \end{cases}

d0d_0 är avståndet där vikten har fallit till 1/e≈37 %1/e \approx 37\,\%. Golvet (0,5 km) finns för att människor bor utspridda över sin ruta, så ett avstånd räknas aldrig som kortare än så.

Avståndsvikten för vardagsbesök

Polygonens besök. Med aca_c de vuxna i befolkningsruta cc, APA_P skogsmarken i polygonen, dcPd_{cP} avståndet från rutans mittpunkt till polygonen, FkF_k skogsmarken i varje annan 1 km-ruta kk (polygonens egen skog borttagen) och VV besöken per år och vuxen:

beso¨k=V⋅∑cac⋅AP w(dcP)AP w(dcP)+∑kFk w(dck)\text{besök} = V \cdot \sum_{c} a_c \cdot \frac{A_P \, w(d_{cP})}{A_P \, w(d_{cP}) + \sum_{k} F_k \, w(d_{ck})}

Bråket är polygonens andel av ruta cc:s besök: dess egen dragningskraft delad med dragningskraften hos allt inom räckhåll.

Implementationen är RecreationCalculator.EverydayShares. Den ger tillbaka termerna per ruta, ac×a_c \times andel, så att anropare (och kalibreringen) kan summera, filtrera eller gruppera dem:

double Weight(double distance) => distance > reach ? 0 : Math.Exp(-Math.Max(distance, floor) / decay);
// …
for (var i = 0; i < population.Count; i++)
{
    var square = population[i];
    var own = square.Adults > 0 ? forestHectares * Weight(square.DistanceMetres) : 0;   // A_P · w(d_cP)
    if (own <= 0)
    {
        continue;
    }
    var elsewhere = 0.0;                                                                 // Σ_k F_k · w(d_ck)
    foreach (var other in others)
    {
        var dx = other.CentreX - square.CentreX;
        var dy = other.CentreY - square.CentreY;
        if (Math.Abs(dx) > reach || Math.Abs(dy) > reach)
        {
            continue;                                   // a cheap box test before the square root
        }
        elsewhere += other.Hectares * Weight(Math.Sqrt(dx * dx + dy * dy));
    }
    shares[i] = square.Adults * own / (own + elsewhere);
}

Utflykter använder samma form med två ändringar: ett längre avstånd d1d_1, och en storleksexponent γ\gamma som låter ett stort, välkänt besöksmål dra mer per hektar än ett litet. Ett besöksmål på DD hektar får dragningskraften DγD^{\gamma}, utspridd över dess hektar som h⋅Dγ−1h \cdot D^{\gamma-1}. En andel ss av varje vuxens besök är utflykter:

utflykter=s⋅V⋅∑cac⋅∑l∈Phl Dlγ−1 w1(dcP)∑l∈Phl Dlγ−1 w1(dcP)+dragningskraften hos all annan beso¨ksmark\text{utflykter} = s \cdot V \cdot \sum_c a_c \cdot \frac{\sum_{l \in P} h_l \, D_l^{\gamma-1}\, w_1(d_{cP})} {\sum_{l \in P} h_l \, D_l^{\gamma-1}\, w_1(d_{cP}) + \text{dragningskraften hos all annan besöksmark}}

RecreationCalculator.ExcursionShares räknar ut den. Nämnarens "all besöksmark inom räckhåll från den här rutan" beror inte på polygonen, så DestinationGridData.Pull räknar den en gång per befolkningsruta och parameteruppsättning och sparar den i en ConcurrentDictionary.

De fria parametrarna är alltså: d0d_0 (satt från litteraturen, inte anpassad), och ss, d1d_1 och γ\gamma, som saknar svensk källa och anpassas.

6.2 Utflykter: rutnätssökning efter s, d₁ och γ

Sorts anpassning: kalibrering med rutnätssökning. Inte regression: det finns ingen formel för de bästa parametrarna, och felytan är inte jämn nog för att lita på en gradientmetod med så få datapunkter. I stället räknas varje kombination på ett rutnät och felen jämförs. Fil: EcoVal.Calibration/ExcursionCalibration.cs.

private static readonly double[] Shares = [0, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35];
private static readonly double[] DecaysKm = [5, 7.5, 10, 15, 20, 30, 50];
private static readonly double[] SizeExponents = [0.7, 1.0, 1.3, 1.6, 2.0, 2.5];

Datat är tre oberoende sorters belägg, som vart och ett låser en egen sida av modellen:

  1. Nivåer. Sju naturreservat i Huddinge med besök räknade ur mobildata (2021).
  2. Ursprung. Samma studies fördelning av var besökarna kom ifrån, per kommun.
  3. En vakt. Gotlands minst besökta reservat (uppskattade till 1–100 besök per år): att lägga till utflykter får inte blåsa upp dem.

Målfunktionen som ska minimeras är summan av tre fel. För parametrarna θ=(s,d1,γ)\theta = (s, d_1, \gamma):

J(θ)=Eniva˚+Eursprung+EvaktJ(\theta) = E_{\text{nivå}} + E_{\text{ursprung}} + E_{\text{vakt}} Eniva˚=1n∑i∈Huddinge[ln⁡max⁡(m^i(θ), 1)ci]2E_{\text{nivå}} = \frac{1}{n} \sum_{i \in \text{Huddinge}} \left[\ln \frac{\max(\hat{m}_i(\theta),\,1)}{c_i}\right]^2 Eursprung=11000∑g[100 (o^g(θ)−og)]2Evakt=[ln⁡median⁡j∈Gotland, la˚gcjm^j(θ)]2E_{\text{ursprung}} = \frac{1}{1000} \sum_{g} \bigl[100\,(\hat{o}_g(\theta) - o_g)\bigr]^2 \qquad E_{\text{vakt}} = \left[\ln \operatorname{median}_{j \in \text{Gotland, låg}} \frac{c_j}{\hat{m}_j(\theta)}\right]^2

cc är ett räknat tal, m^\hat{m} modellens, ogo_g den rapporterade andelen besök från ursprung gg och o^g\hat{o}_g den modellerade. Den kvadrerade logkvoten ser "dubbelt för högt" och "hälften så mycket" som lika fel, vilket är rätt för räkningar som spänner över flera tiopotenser. Delningen med 1000 lägger ursprungsfelet (i kvadrerade procentenheter) på ungefär samma skala som de två andra, så varje term är omkring 1 för en dålig anpassning.

private static Fit Evaluate(/* … */)
{
    var huddinge = areas.Where(area => area.Area.Region == "Huddinge").ToList();
    var levelError = huddinge.Average(area =>
        Math.Pow(Math.Log(Math.Max(ModelledKept(area, share, combo, perAdult), 1) / area.Area.Visits), 2));

    var origins = OriginShares(huddinge, share, combo);
    var originError = OriginSplit.Reported.Sum(row => Math.Pow(100 * (origins.GetValueOrDefault(row.Code) - row.Share), 2)) / 1_000;

    var lowClass = areas.Where(area => area.Area.Region == "Gotland" && area.Area.VisitsHigh <= 100).ToList();
    var lowRatio = Median(lowClass.Select(area => area.Area.Visits / Math.Max(Modelled(area, share, combo, perAdult), 1)));
    // …
}

Jämföra lika med lika. Mobildatat räknar inte alla: det utelämnar dem som bor inom 400 m och vistelser under 20 minuter. MobileDataFilter.Kept(distance, …) ger den andel av besöken från ett hem på ett visst avstånd som telefonerna skulle ha räknat, och modellens termer per ruta multipliceras med den före jämförelsen (ModelledKept). Att anpassa den ofiltrerade modellen till filtrerade räkningar skulle snedvrida varje parameter.

Varför sökningen går fort. Det dyra är de rumsliga summorna, och ss går in i modellen linjärt:

m^(θ)=V[(1−s) E+s Xd1,γ]\hat{m}(\theta) = V \bigl[(1 - s)\,E + s\,X_{d_1,\gamma}\bigr]

Så ComputeAsync räknar EE (vardagsandelar) en gång per område och XX (utflyktsandelar) en gång per par (d1,γ)(d_1, \gamma), och loopen över ss är vanlig aritmetik:

private static double Modelled(AreaShares area, double share, int combo, double perAdult) =>
    perAdult * ((1 - share) * area.Everyday + share * area.Excursion[combo]);
flowchart LR
    A["För varje räknat område:<br/>vardagsandelar E<br/>utflyktsandelar X per (d₁, γ)"] --> B["För varje s, d₁, γ på rutnätet:<br/>modell = V·((1−s)·E + s·X)"]
    B --> C["Målfunktion J =<br/>nivå + ursprung + vakt"]
    C --> D["Sortera efter J,<br/>skriv de 15 bästa till excursions.md"]
    D --> E["Utvecklaren väljer lågt, centralt, högt<br/>och ändrar RecreationOptions.Excursion"]

Resultatet och hur det används. Rapportens bästa uppsättning var s=0,35s = 0{,}35, d1=7,5d_1 = 7{,}5 km, γ=2\gamma = 2 (J=0,503J = 0{,}503), med flera grannar nästan lika bra. De sparade värdena är inte bara minimum; kommentaren på inställningen förklarar bedömningen som gjordes (anpassningen trycker ss till sin gräns, och γ=2\gamma = 2 skulle låta de största besöksmålen dominera):

// RecreationOptions.cs
public List<ExcursionParameters> Excursion { get; set; } =
[
    new(0.25, 10, 1.6),     // low:     s, d₁ km, γ
    new(0.30, 10, 1.6),     // central
    new(0.35, 20, 1.6),     // high
];

RecreationCalculator.Excursions kör modellen en gång per fall och bygger ValueRange av de tre resultaten.

6.3 Turism, vart gästerna går: rutnätssökning med en anpassad skalfaktor

Fil: EcoVal.Calibration/AttractionCalibration.cs. Sorts anpassning: rutnätssökning, med en endimensionell numerisk minimering inuti.

Modellen. En kommuns gästnätter fördelas på dess besöksmark. En andel 1−α1 - \alpha går efter yta, och en andel α\alpha efter attraktivitet, där mark nära parkeringar, ledstarter, utsiktsplatser och badplatser är mer attraktiv:

andelP=(1−α) andelPyta+α andelPattraktion\text{andel}_P = (1 - \alpha)\,\text{andel}^{\text{yta}}_P + \alpha\,\text{andel}^{\text{attraktion}}_P A(x)=∑punkter jωsort(j) exp⁡ ⁣(−d(x,j)dw)\mathcal{A}(x) = \sum_{\text{punkter } j} \omega_{\text{sort}(j)} \, \exp\!\left(-\frac{d(x, j)}{d_w}\right)

A(x)\mathcal{A}(x) är attraktiviteten på en plats xx: varje entrépunkt lägger till sin sorts vikt ω\omega, som avtar med avståndet i takten dwd_w. I koden är blandningen en rad:

// RecreationContracts.cs
public double Combined(double attractionShare) => (1 - attractionShare) * Area + attractionShare * Attraction;

Rutnätet täcker α\alpha (9 värden), dwd_w (4 värden) och vikterna för fyra grupper av entrépunkter (var och en 0, 1, 3 eller 10; bara deras förhållanden spelar roll, så WeightSets() normaliserar och tar bort dubbletter).

Den inre anpassningen. Gotlands 158 räknade reservat modelleras som

m^i=Ri+k⋅Gi(α,dw,ω)\hat{m}_i = R_i + k \cdot G_i(\alpha, d_w, \omega)

med RiR_i de boendes besök (från utflyktsmodellen, fasta) och GiG_i de gästnätter som kandidaten skickar till reservat ii. Faktorn kk (besök per gästnatt) är okänd och ointressant här; det som räknas är om formen är rätt, alltså om välbesökta reservat kommer ut som välbesökta. Så för varje kandidat på rutnätet hittas först det bästa kk, och kandidaten får sitt betyg vid det kk:

E(α,dw,ω)=min⁡k 1n∑i[ln⁡max⁡(Ri+k Gi, 1)ci]2E(\alpha, d_w, \omega) = \min_{k}\ \frac{1}{n}\sum_i \left[\ln \frac{\max(R_i + k\,G_i,\ 1)}{c_i}\right]^2

Det inre minimumet över kk använder gyllene snittet-sökning, en metod för att hitta minimum av en funktion av en variabel utan derivator. Den håller ett intervall som innehåller minimum och krymper det med gyllene snittet φ=(5−1)/2≈0,618\varphi = (\sqrt{5}-1)/2 \approx 0{,}618 i varje steg:

double Error(double logK) => SquaredLogError(gotland, guestNights, Math.Exp(logK));
double low = Math.Log(1e-3), high = Math.Log(30);
var ratio = (Math.Sqrt(5) - 1) / 2;
for (var i = 0; i < 60; i++)
{
    var a = high - ratio * (high - low);
    var b = low + ratio * (high - low);
    if (Error(a) < Error(b))
    {
        high = b;          // the minimum lies in [low, b]
    }
    else
    {
        low = a;           // the minimum lies in [a, high]
    }
}
var k = Math.Exp((low + high) / 2);

Sökningen görs på ln⁡k\ln k, så den täcker kk från 0,001 till 30 jämnt i relativa termer. Sextio steg krymper intervallet med 0,61860≈10−130{,}618^{60} \approx 10^{-13}, långt mer än vad som behövs.

Resultatet sparas i TourismOptions: AttractionShare = new(0.8, 0.9, 1), AttractionDecayKm = 0.5 och AccessPointWeights. Kommentarerna anger vad anpassningen kunde och inte kunde avgöra: dwd_w ligger på kanten av sitt rutnät, och flera viktuppsättningar passar ungefär lika bra.

6.4 Turism, besök per gästnatt: en rutnätssökning som inte kunde avgöra

Fil: EcoVal.Calibration/TourismCalibration.cs. Sorts anpassning: rutnätssökning, över qq (naturbesök per gästnatt) för storstadskommuner och för övriga kommuner, med samma tredelade målfunktion som utflyktsanpassningen (Huddinges nivåer, Gotlands välbesökta reservat, Gotlands stilla reservat som vakt):

private static readonly double[] OtherGrid = [0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.4, 0.5, 0.75, 1.0];
private static readonly double[] CityGrid = [0, 0.01, 0.02, 0.05, 0.1, 0.2];
// …
public double Objective => LevelError + TouristError + GuardError;

Det här är det lärorika fallet med en kalibrering som kördes men inte fick fast parametern. Kommentarerna på inställningarna säger det rakt ut: värdena är "a first estimate", eftersom de räknade data knappt rör sig med qq. Kalibreringen finns kvar för att den rapporterar hur de inställda värdena står sig, och för att den kommer att avgöra frågan när bättre räkningar finns. En anpassning är bara så bra som datats förmåga att skilja kandidatvärden åt.

6.5 Fiskedagar: viktad minsta kvadrat på ett rutnät

Fil: EcoVal.Calibration/FishingCalibration.cs. Sorts anpassning: rutnätssökning som minimerar en viktad kvadratsumma (χ²). Det här är det renaste exemplet av de fyra.

Problemet. En nationell enkät ger fiskedagarna per år för några stora områden. Sidan behöver dagar för en enskild sjö. Att fördela en regions dagar enbart efter vattenyta blir rejält fel: det ger Vänern 1,2 miljoner dagar där enkäten fann 233 000.

Modellen. En andel β\beta av dagarna följer människorna som bor nära varje vatten, och resten följer hektaren. För område AA, med TT totala dagar, HH totala hektar och PAP_A områdets "dragningskraft" på människor:

dagarA=T[(1−β) haAH+β PA∑A′PA′]\text{dagar}_A = T \left[(1 - \beta)\,\frac{\text{ha}_A}{H} + \beta\,\frac{P_A}{\sum_{A'} P_{A'}}\right]

Dragningskraften använder samma avståndsviktade fördelning som avsnitt 6.1, nu för vatten. Varje befolkningsruta cc delar sina vuxna aca_c mellan alla vattenrutor inom räckhåll efter hektar ×\times w(d)w(d):

PA=∑cac⋅∑l∈Ahl w(dcl)∑k∈allt vattenhk w(dck),w(d)=exp⁡ ⁣(−max⁡(d,dgolv)d1)P_A = \sum_c a_c \cdot \frac{\sum_{l \in A} h_l \, w(d_{cl})}{\sum_{k \in \text{allt vatten}} h_k \, w(d_{ck})}, \qquad w(d) = \exp\!\left(-\frac{\max(d, d_{\text{golv}})}{d_1}\right)

FishingGridData.Compute (EcoVal.Api/Features/Water/Lake/FishingGrid.cs) räknar ut den för omkring 95 000 befolkningsrutor mot 160 000 vattenrutor. Den indexerar vattnet i 10 km-block så att varje hem bara tittar på närliggande block, kör hemmen parallellt med Parallel.For och sparar resultatet per avståndsinställning:

Parallel.For(0, _homes.Length, i =>
{
    var home = _homes[i];
    var byArea = new double[_areas.Length];
    // … for each 10 km block within reach of the home …
    foreach (var (square, area) in block)
    {
        byArea[area] += square.Hectares * Weight(square.CentreX - home.X, square.CentreY - home.Y, distance);
    }
    total[i] = byArea.Sum();        // the denominator: this home's pull to all water
    byHome[i] = byArea;
});

Målfunktionen. Varje enkättal kommer med en felmarginal. Ett tal som enkäten är osäker på ska väga mindre, så varje kvadrerat fel delas med talets varians. Med σA\sigma_A = felmarginalen ÷ 1,96 (marginalen är ett 95 % intervall, 1,96 standardavvikelser brett):

χ2(d1,β)=∑A(dagarA(d1,β)−enka¨tAσA)2\chi^2(d_1, \beta) = \sum_A \left(\frac{\text{dagar}_A(d_1, \beta) - \text{enkät}_A}{\sigma_A}\right)^2
foreach (var share in ShareGrid)       // β = 0, 0.05, …, 1
{
    var days = targets
        .Select((_, i) => total * ((1 - share) * hectares[i] / allHectares + share * pull[i] / allPull))
        .ToArray();
    var chi = targets.Select((target, i) => Math.Pow((days[i] - target.Days) / target.Sigma, 2)).Sum();
    fits.Add(new Fit(decay, reach, share, chi, days));
}
// …
var best = fits.MinBy(fit => fit.ChiSquare)!;

Dragningskrafterna (dyra) räknas en gång per d1d_1 i den yttre loopen; loopen över β\beta inuti är aritmetik, samma knep som i 6.2.

Anpassningens fel för varje avstånd

Från bästa anpassning till ett intervall. χ² ger också ett välgrundat intervall. För en anpassning som den här är de parametervärden vars χ² ligger inom 1 från minimum de som datat inte kan förkasta på ungefär en standardavvikelse. Rapporten listar dem, och de blev det låga, centrala och höga fallet:

// LakeOptions.cs
public List<FishingPeopleCase> FishingByPeople { get; set; } =
[
    new() { DecayKm = 0.75, PeopleShare = 0.85 },    // low
    new() { DecayKm = 1.5, PeopleShare = 0.90 },     // central: the best fit, χ² 0.10
    new() { DecayKm = 3, PeopleShare = 0.90 },       // high
];
Enkäten mot den anpassade modellen

Hur API:et använder den. Anpassningen gjordes på fyra områden, men sidan behöver vilken sjö som helst i vilken region som helst. Så det anpassade β\beta görs först om till en storhet som går att flytta: rr, de fiskedagar per år som en vuxen gör på vatten nära hemmet.

r=β⋅T∑A∈anpassningsomra˚denPAr = \frac{\beta \cdot T}{\sum_{A \in \text{anpassningsområden}} P_A}

En sjö LL i region RR (med regionens dagar DRD_R från enkäten) får sedan r⋅PLr \cdot P_L dagar från människorna nära den, och sin andel efter yta av det regionen har kvar:

βR=min⁡ ⁣(1, r⋅PRDR)dagarL=DR[(1−βR) haLhaR+βR PLPR]\beta_R = \min\!\left(1,\ \frac{r \cdot P_R}{D_R}\right) \qquad \text{dagar}_L = D_R \left[(1 - \beta_R)\,\frac{\text{ha}_L}{\text{ha}_R} + \beta_R\,\frac{P_L}{P_R}\right]
// LakeCalculator.cs
private static double Rate(FishingPullCase pullCase, double fitDays, LakeOptions options) =>
    options.FishingFitAreas.Sum(code => pullCase.AreaPull.GetValueOrDefault(code)) is var fitPull and > 0
        ? pullCase.PeopleShare * fitDays / fitPull
        : 0;

// inside RegionShares:
peopleShare = Math.Min(1, rate * regionPull / regionDays);
var lakePull = pullCase.Lakes.GetValueOrDefault(lake.Id).Pull;
return regionDays * ((1 - peopleShare) * lake.Hectares / regionHectares + peopleShare * lakePull / regionPull);

Lägg märke till vad som är och inte är hårdkodat: d1d_1 och β\beta är sparade, men rr räknas om från dem och de aktuella befolknings- och vattendata vid varje start, så det följer datat.

6.6 Formhöjd efter ålder: en klassvis kvot som blir en uppslagstabell

Fil: EcoVal.Calibration/FormHeightCalibration.cs. Sorts anpassning: en empirisk tabell, inte regression. Ingen funktionsform antas alls.

Vad den är till för. Startsidans kalkylator känner ett typiskt bestånds volym, men dess bärmodeller behöver grundytan. Formhöjden är bron: F=V/GF = V / G (volym ÷ grundyta, i meter).

Metoden. Dra slumpade 30 m-rutor över Sverige tills 20 000 har skog och data i alla fyra raster, sortera dem i 10-åriga åldersklasser kk och ta kvoten av summorna i varje klass:

Fk=∑i∈kVi∑i∈kGiF_k = \frac{\sum_{i \in k} V_i}{\sum_{i \in k} G_i}

Kvoten av summorna (inte medelvärdet av varje rutas kvot) väger varje ruta efter dess grundyta, så att glesa unga rutor med ostadiga kvoter inte förvränger klassen.

var random = new Random(20261030);          // a fixed seed: the same squares on every run
// …
var age = (ageSpruce + agePine) / 2;
var key = Math.Min(LastClass, (int)(age / ClassYears) * ClassYears);
var entry = classes.GetValueOrDefault(key);
classes[key] = (entry.Volume + volume, entry.BasalArea + basalArea, entry.Count + 1);

Varje rutas värden kommer från ZonalStatistics.Compute (avsnitt 2.2), samma kod som API:et använder.

Använda den. Tabellen sparas i CalculatorOptions med varje klass mittålder som nyckel, och läses med linjär interpolation: räta linjer mellan åldrarna, plant utanför ändarna.

F(a)=Fi+a−aiai+1−ai (Fi+1−Fi)fo¨r ai≤a≤ai+1F(a) = F_i + \frac{a - a_i}{a_{i+1} - a_i}\,(F_{i+1} - F_i) \qquad \text{för } a_i \le a \le a_{i+1}
// ForestStandCalculator.cs
private static double Interpolated(Dictionary<double, double> byAge, double age)
{
    var table = byAge.OrderBy(entry => entry.Key).ToList();
    if (age <= table[0].Key)
    {
        return table[0].Value;
    }
    for (var i = 1; i < table.Count; i++)
    {
        if (age <= table[i].Key)
        {
            var (from, to) = (table[i - 1], table[i]);
            return from.Value + (age - from.Key) / (to.Key - from.Key) * (to.Value - from.Value);
        }
    }
    return table[^1].Value;
}
Formhöjd efter beståndsålder

6.7 Kantarellens habitat: logistisk regression med ridge-straff, prövad och utelämnad

Filer: EcoVal.Calibration/ChanterelleCalibration.cs och ChanterelleModel.cs. Sorts anpassning: statistisk regression (en generaliserad linjär modell), tränad iterativt och validerad på undanhållna data. Det här är den enda modellen i kodbasen som en dataanalytiker skulle känna igen som "tränad", och den som ligger närmast maskininlärning. API:et använder den inte: den slog knappt slumpen, så inget betyg visas. Den ligger kvar i kodbasen så att anpassningen kan göras om på bättre data, och den är det bästa genomarbetade exemplet på en hel träningskedja.

flowchart TB
    A["Nedladdningar från GBIF:<br/>kantarellfynd (y = 1)<br/>21 andra svampar (y = 0)"] --> B["Filtrera och gallra<br/>ett fynd per 100 m-ruta"]
    B --> C["Läs beståndet i en 60 m-ruta<br/>8 indata per fynd"]
    R["12 000 slumpade skogsrutor<br/>(referensurval)"] --> D
    C --> D["Håll inom 1:a–99:e percentilen<br/>lägg till kvadrattermer (12 termer)<br/>standardisera på referensen"]
    D --> E["Anpassa: viktad logistisk regression med ridge<br/>(Newton / IRLS)"]
    D --> F["Validera: 5 delar av hela 100 km-block<br/>AUC på den undanhållna delen"]
    E --> G["chanterelle.md:<br/>koefficienter, standardfel, AUC"]
    F --> G

Modellen. Sannolikheten att ett fynd är en kantarell, givet platsens termer xx:

p(x)=11+e−η(x)η(x)=β0+∑j=112βj zjzj=xj−μjσjp(x) = \frac{1}{1 + e^{-\eta(x)}} \qquad \eta(x) = \beta_0 + \sum_{j=1}^{12} \beta_j \, z_j \qquad z_j = \frac{x_j - \mu_j}{\sigma_j}

De tolv termerna är åtta indata (ålder, grundyta, tallandel, granandel, ståndortsindex, torr andel, blöt andel, nordkoordinat) plus kvadraterna på fyra av dem, så att svaret kan ha en topp mitt i ett intervall (ChanterelleModel.Raw). Varje term standardiseras med medelvärdet μj\mu_j och standardavvikelsen σj\sigma_j i det slumpade skogsurvalet, så en koefficient läses som "per standardavvikelse av svensk skog" och ridge-straffet behandlar alla termer lika.

Vad som minimeras. Den straffade, viktade negativa log-likelihooden:

L(β)=−∑iωi[yiln⁡pi+(1−yi)ln⁡(1−pi)]+λ2∑j≥1βj2\mathcal{L}(\beta) = -\sum_i \omega_i \bigl[y_i \ln p_i + (1 - y_i)\ln(1 - p_i)\bigr] + \frac{\lambda}{2}\sum_{j \ge 1} \beta_j^2
  • ωi\omega_i är en klassvikt: 1 för fynd och n1/n0n_1 / n_0 för bakgrundsfynd, så att båda klasserna väger lika totalt fast bakgrundsfynden är många fler än fynden.
  • Den sista termen är ridge-straffet (λ=1\lambda = 1). Det drar koefficienterna mot noll, vilket hindrar korrelerade termer (ålder och ålder²) från att ta enorma motsatta värden. Interceptet β0\beta_0 straffas inte.

Hur det minimeras. Det finns ingen sluten lösning, så anpassningen använder Newtons metod, som för logistisk regression kallas iterativt omviktad minsta kvadrat (IRLS). Varje iteration räknar gradienten gg och Hessianen HH vid nuvarande β\beta och tar ett steg:

g=∑iωi (yi−pi) xi−λ β(j≥1)H=∑iωi pi(1−pi) xixi⊤+λ I(j≥1)g = \sum_i \omega_i\,(y_i - p_i)\,x_i - \lambda\,\beta_{(j \ge 1)} \qquad H = \sum_i \omega_i\,p_i(1 - p_i)\,x_i x_i^{\top} + \lambda\,I_{(j \ge 1)} β←β+H−1g\beta \leftarrow \beta + H^{-1} g
for (; iterations < 50; iterations++)
{
    hessian = new double[k, k];
    var gradient = new double[k];
    foreach (var (x, y, _) in rows)
    {
        var row = Row(x);                                                    // [1, x₁, …]
        var p = 1 / (1 + Math.Exp(-row.Select((v, i) => v * beta[i]).Sum())); // p = 1 / (1 + e^(−η))
        var w = weight(y);
        for (var i = 0; i < k; i++)
        {
            gradient[i] += w * (y - p) * row[i];
            for (var j = 0; j < k; j++)
            {
                hessian[i, j] += w * p * (1 - p) * row[i] * row[j];
            }
        }
    }
    for (var i = 1; i < k; i++)                    // the ridge, skipping the intercept
    {
        gradient[i] -= Ridge * beta[i];
        hessian[i, i] += Ridge;
    }
    var step = Solve(hessian, gradient);           // solves H · step = g
    for (var i = 0; i < k; i++)
    {
        beta[i] += step[i];
    }
    if (step.Max(Math.Abs) < 1e-8)
    {
        break;                                     // converged
    }
}

Solve är Gausselimination med partiell pivotering, omkring 30 rader, vilket är all linjär algebra ett system på 13 × 13 behöver. Anpassningen konvergerade på 4 iterationer. Varje koefficients standardfel faller ut ur samma matris:

se⁡(βj)=(H−1)jj\operatorname{se}(\beta_j) = \sqrt{\bigl(H^{-1}\bigr)_{jj}}
var errors = Enumerable.Range(0, k).Select(i => Math.Sqrt(Solve(hessian, Unit(k, i))[i])).ToArray();

Skydd mot extrapolering. Kvadrattermer skenar utanför det intervall modellen har sett. Därför hålls varje indata inom 1:a–99:e percentilen av träningsfynden, både vid anpassning och vid förutsägelse (ChanterelleModel.Clamped).

Validering: rumslig korsvalidering i block. En modell måste bedömas på data den inte anpassats till. Vanlig korsvalidering skulle fuska här, eftersom fynd från samma skog är nästan dubbletter: en modell kan få bra betyg genom att lära sig platser utantill. Därför hålls hela 100 km-block undan tillsammans:

var foldOf = blocks.OrderBy(_ => random.Next()).Select((block, i) => (block, fold: i % 5)).ToDictionary(/* … */);
for (var fold = 0; fold < 5; fold++)
{
    var train = rows.Where(row => foldOf[row.Block] != fold).ToList();
    var test = rows.Where(row => foldOf[row.Block] == fold).ToList();
    var beta = Fit(train, columns, weight).Beta;        // fitted without the held-out blocks
    // … score the held-out rows with beta …
}

Betyget: AUC. Ytan under ROC-kurvan är chansen att ett slumpvis valt fynd får högre poäng än ett slumpvis valt bakgrundsfynd. 0,5 är slantsingling, 1 är perfekt. Den räknas från rangtal (Mann–Whitneys statistika): sortera alla poäng, summera rangtalen R+R_+ för de n+n_+ fynden, och

AUC=R+−n+(n++1)2n+ n−\text{AUC} = \frac{R_+ - \dfrac{n_+(n_+ + 1)}{2}}{n_+ \, n_-}
return positives == 0 || negatives == 0
    ? double.NaN
    : (rankSum - positives * (positives + 1) / 2.0) / ((double)positives * negatives);

Lika poäng delar på medelvärdet av sina rangtal, vilket loopen ovanför den här raden sköter.

Hur väl kantarellmodellen skiljer fynd från bakgrund

Utfallet. AUC på undanhållna data blev 0,580, mot 0,532 för en modell som bara vet hur långt norrut en plats ligger. Att utelämna en enskild grupp av termer ändrade AUC med mindre än 0,01. Med enkla ord: beståndsdata skiljer kantarellplatser från andra svampplatser bara lite bättre än en slant, så modellen lades inte in i appen. Kalibreringen visar också varför valet av bakgrund spelar roll: mot alla svampar lärde sig modellen mest var naturvårdsinventeringar görs, och därför snävades bakgrunden in till svampar som plockare rapporterar.

Hur den skulle användas. ChanterelleModel.LinearPredictor och Ratio är förutsägelsesidan, färdig om en bättre anpassning kommer. De utelämnar interceptet (det speglar bara hur många bakgrundspunkter som drogs) och ger en kvot mot genomsnittlig svensk skog, inte en sannolikhet:

kvot(x)=eη(x)medel⁡referens eη\text{kvot}(x) = \frac{e^{\eta(x)}}{\operatorname{medel}_{\text{referens}}\, e^{\eta}}
public static double Ratio(ChanterelleSite site, ChanterelleOptions options) =>
    Math.Exp(LinearPredictor(site, options)) / options.ReferenceMeanExp;

7. Köra en kalibrering igen

  1. Starta appen med aspire run så att PostGIS är uppe och inläsningen har körts.
  2. Starta resursen calibration i Aspires dashboard. Som standard kör den excursions, attraction, tourism och fishing. Sätt Calibration__Models=form-height eller chanterelle för de två som körs på begäran (de läser rastren i tiotusentals punkter).
  3. Läs rapporten i data/calibration/. Varje rapport skriver de inställda värdena bredvid de bästa på rutnätet, så det syns direkt om de sparade parametrarna fortfarande håller.
  4. För att ta in nya värden: ändra standardvärdena i options-klassen, uppdatera XML-kommentaren med datum och tal, och uppdatera docs/calculations.md. Ingenting läser rapporten automatiskt.

Anpassningarna vid körning i avsnitt 5 behöver inget steg: de byggs om från databasen när API:et startar.

En checklista för att lägga till en anpassad parameter

  • Håll modellen som en ren funktion i API-projektet, och låt kalibreringen anropa den funktionen.
  • Jämför modellen med datat på datats egna villkor (mobildatafiltret i 6.2 är exemplet).
  • Håll undan något som vakt eller kontroll, så att anpassningen inte kan köpa träffsäkerhet på ett ställe genom att förstöra ett annat.
  • Spara lågt, centralt och högt, inte bara det bästa värdet, och skriv i inställningens kommentar vad datat kunde och inte kunde avgöra.