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:
- 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).
- 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
- 2. Från ritad yta till pixlar
- 3. Typerna som bär ett resultat
- 4. Vilken sorts regression använder EcoVal?
- 5. Anpassningar som API:et gör vid körning
- 6. Anpassningar som görs i förväg av EcoVal.Calibration
- 7. Köra en kalibrering igen
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.Calibrationanropar 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 ha värdet , och låt 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.
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 är pixelstorleken i meter:
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.
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
Mosaik. Ett raster kommer som många filer (tiles).
ReadMosaiclä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.Täckning.
CoverageCellsräknar ut 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.
- Först märks de pixlar som gränsen går igenom (
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 :te rad och kolumn.
Formeln. Med ett fönster på pixlar och en budget på stickprov blir steget
och varje stickprov står för pixlar, så ytan av klass är
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:
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:
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-calibrationoch/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:
där är den vattentäckta bredden i meter och ytan som avvattnas genom punkten i km².
Anpassningen. Med och över de lokalerna har minsta kvadratmetoden en sluten lösning:
är den andel av variationen i 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
När detta skrivs är anpassningen från 4 126 lokaler, med
(docs/calculations-water.md). Ett 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 och en kvantil :
// 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 med längd (m), modellerad bredd (m) och klassens täthet (öringungar per 100 m²):
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 å räknar modellen ut , de öringungar dess egen metod förutsäger ovanför fällan, och delar varje års räkning med det:
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:
var ratios = young > 0 ? river.Smolts.Values.Select(smolts => smolts / young).Order().ToList() : [];
Det här är en kalibrering med kvot: faktorn 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:
// 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 från ett hem får vikten
är avståndet där vikten har fallit till . 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å.
Polygonens besök. Med de vuxna i befolkningsruta , skogsmarken i polygonen, avståndet från rutans mittpunkt till polygonen, skogsmarken i varje annan 1 km-ruta (polygonens egen skog borttagen) och besöken per år och vuxen:
Bråket är polygonens andel av ruta :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,
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 , och en storleksexponent som låter ett stort, välkänt besöksmål dra mer per hektar än ett litet. Ett besöksmål på hektar får dragningskraften , utspridd över dess hektar som . En andel av varje vuxens besök är utflykter:
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å: (satt från litteraturen, inte anpassad), och , och , 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:
- Nivåer. Sju naturreservat i Huddinge med besök räknade ur mobildata (2021).
- Ursprung. Samma studies fördelning av var besökarna kom ifrån, per kommun.
- 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 :
är ett räknat tal, modellens, den rapporterade andelen besök från ursprung och 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 går in i modellen linjärt:
Så ComputeAsync räknar (vardagsandelar) en gång per område och (utflyktsandelar) en gång per par
, och loopen över ä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 , km, (), 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 till sin gräns, och 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 går efter yta, och en andel efter attraktivitet, där mark nära parkeringar, ledstarter, utsiktsplatser och badplatser är mer attraktiv:
är attraktiviteten på en plats : varje entrépunkt lägger till sin sorts vikt , som avtar med avståndet i takten . I koden är blandningen en rad:
// RecreationContracts.cs
public double Combined(double attractionShare) => (1 - attractionShare) * Area + attractionShare * Attraction;
Rutnätet täcker (9 värden), (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
med de boendes besök (från utflyktsmodellen, fasta) och de gästnätter som kandidaten skickar till reservat . Faktorn (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 , och kandidaten får sitt betyg vid det :
Det inre minimumet över 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 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å , så den täcker från 0,001 till 30 jämnt i relativa termer. Sextio steg krymper intervallet med , 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: 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 (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 . 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 av dagarna följer människorna som bor nära varje vatten, och resten följer hektaren. För område , med totala dagar, totala hektar och områdets "dragningskraft" på människor:
Dragningskraften använder samma avståndsviktade fördelning som avsnitt 6.1, nu för vatten. Varje befolkningsruta delar sina vuxna mellan alla vattenrutor inom räckhåll efter hektar :
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 = felmarginalen ÷ 1,96 (marginalen är ett 95 % intervall, 1,96 standardavvikelser brett):
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 i den yttre loopen; loopen över inuti är aritmetik, samma knep som i 6.2.
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
];
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 görs först om till en storhet som går att flytta: , de fiskedagar per år som en vuxen gör på vatten nära hemmet.
En sjö i region (med regionens dagar från enkäten) får sedan dagar från människorna nära den, och sin andel efter yta av det regionen har kvar:
// 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: och är sparade, men 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: (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 och ta kvoten av summorna i varje klass:
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.
// 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;
}
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 :
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 och standardavvikelsen 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:
- är en klassvikt: 1 för fynd och 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 (). Det drar koefficienterna mot noll, vilket hindrar korrelerade termer (ålder och ålder²) från att ta enorma motsatta värden. Interceptet 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 och Hessianen vid nuvarande och tar ett steg:
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:
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 för de fynden, och
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.
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:
public static double Ratio(ChanterelleSite site, ChanterelleOptions options) =>
Math.Exp(LinearPredictor(site, options)) / options.ReferenceMeanExp;
7. Köra en kalibrering igen
- Starta appen med
aspire runså att PostGIS är uppe och inläsningen har körts. - Starta resursen
calibrationi Aspires dashboard. Som standard kör denexcursions,attraction,tourismochfishing. SättCalibration__Models=form-heightellerchanterelleför de två som körs på begäran (de läser rastren i tiotusentals punkter). - 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. - 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.