⚡ electrical engineering

Worst-case Nonlinear Regression with Error Bounds

Deze paper introduceert een actief leermethode voor niet-lineaire minimax-regressie die een surrogate-model optimaliseert door de maximale absolute benaderingsfout te minimaliseren, gebruikmakend van een gladde $L_\infty$ -benadering voor training en het iteratief toevoegen van punten met de grootste fout, terwijl er bovendien worst-case foutgrenzen worden afgeleid.

Oorspronkelijke auteurs: Alberto Bemporad

Gepubliceerd 2026-04-24

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Alberto Bemporad

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een zeer complexe, onvoorspelbare machine probeert te begrijpen. Misschien is het een auto die op een vreemde manier reageert op het gaspedaal, of een weermodel dat de windrichting voorspelt. Je wilt een simpele, snelle "stuurman" (een computerprogramma) bouwen die het gedrag van die machine nabootst, zodat je er snel beslissingen mee kunt nemen.

In de wereld van kunstmatige intelligentie (AI) doen we dit meestal door een model te trainen met duizenden voorbeelden. De standaardmethode is als het leren van een pianist: je speelt veel stukken en kijkt naar de gemiddelde fout. Als je gemiddeld maar één noot verkeerd speelt, denken we: "Groot werk!"

Maar in de echte wereld, vooral bij veiligheidskritische systemen (zoals een zelfrijdende auto of een robot in een fabriek), maakt de gemiddelde fout niet uit. Wat telt, is het slechtst mogelijke scenario. Als die pianist één keer een vreselijke noot slaat die het hele orkest laat stoppen, is dat een ramp.

Dit paper, geschreven door Alberto Bemporad, introduceert een nieuwe manier om zulke modellen te bouwen. Het noemen het "Worst-case Nonlinear Regression". Laten we het uitleggen met een paar simpele metaforen.

1. Het probleem: De "Gemiddelde" Leugen

Stel je voor dat je een kaart wilt maken van een berggebied.

De oude manier (MSE): Je kijkt naar de gemiddelde hoogteverschillen. Je kaart is over het algemeen goed, maar op één specifieke, gevaarlijke helling (de "worst case") is je kaart 50 meter fout. Als je daar met een auto over rijdt, val je in een ravijn. De gemiddelde fout was klein, maar het risico was groot.
De nieuwe manier (Worst-case): We willen een kaart maken waar we garantie op kunnen geven dat we nergens meer dan 1 meter van de werkelijkheid afwijken. We willen de "ergste fout" zo klein mogelijk maken.

2. De oplossing: De "Slimme Zoeker" (Actief Leren)

Hoe bouw je zo'n perfecte kaart? Je kunt niet overal meten. Je moet slim kiezen waar je gaat meten.

Het paper stelt een proces voor dat werkt als een detective die op zoek is naar de zwakke plekken:

Begin met een schets: Je tekent eerst een ruwe kaart met een paar willekeurige metingen.
Zoek de fout: Je laat een slimme computer (een "globale optimizer") zoeken naar het punt op de kaart waar jouw schets het meest afwijkt van de werkelijkheid. Waar zit de grootste leugen?
Meet daar: Je gaat naar dat ene punt, meet de echte waarde en voegt het toe aan je dataset.
Herhaal: Je hertraint je model met die nieuwe informatie en zoekt weer naar de volgende grootste fout.

Dit noemen ze Actief Leren. In plaats van willekeurig te meten, jaagt je algoritme op de "ergste gevallen" (de corner cases) en stopt pas als de grootste fout klein genoeg is.

3. De wiskundige truc: De "Zachte" Piek

Het grootste probleem bij dit soort "ergste geval"-rekenen is dat wiskundig gezien de "piek" van een fout heel scherp en onhandig is voor computers om te berekenen. Het is alsof je een bal probeert te laten rollen op een berg met een scherp, puntig piekje; de computer raakt in de war.

De auteur lost dit op door de scherpe piek te vervangen door een gladde, zachte heuvel.

Metafoor: Denk aan een scherpe ijspegel (de echte fout). Dat is lastig om te beklimmen. De auteur maakt er een zachte sneeuwhoop van. De computer kan nu makkelijk "op de heuvel rollen" om de top te vinden, maar omdat de heuvel bijna net zo hoog is als de ijspegel, vinden we toch de juiste plek. Zodra we de top hebben gevonden, weten we dat de ijspegel er ook was.

4. De Veiligheidsnetjes: De "Onzekerheidsband"

Na het trainen van het model, wil je weten: "Hoeveel mag ik me vergissen?"
Het paper biedt twee manieren om dit te garanderen:

Een vast veiligheidsnet: "Overal op de kaart mag je maximaal 1 meter fout zitten." (Dit is een constante grens).
Een slim veiligheidsnet: "In de vlakke valleien mag je 10 centimeter fout zitten, maar op de steile hellingen mag je 2 meter fout zitten." (Dit is een input-afhankelijke grens).

Dit is cruciaal voor Model Predictive Control (MPC). Dit is een geavanceerde besturingsmethode die gebruikt wordt in industriële processen. Vaak zijn deze besturingswetten zo complex dat ze te langzaam zijn voor een snelle computer. Door ze te vervangen door een snellere, simpele AI-versie, willen we zeker weten dat die snelle versie de machine niet laat crashen. Met deze methode kunnen we zeggen: "De snelle AI mag maximaal X% fout hebben, en we weten precies waar die grens ligt."

5. Waar is dit goed voor?

De auteurs tonen aan dat dit werkt voor:

Het nabootsen van complexe wiskundige formules.
Het vinden van veilige gebieden in een landschap (bijvoorbeeld: "Hier mag je niet komen").
Het voorspellen van het gedrag van mechanische systemen (zoals een slinger met wrijving).
Het versnellen van complexe besturingssystemen in auto's of fabrieken.

Samenvattend

Dit paper is als het ontwikkelen van een onfeilbare navigatiesysteem voor een auto. In plaats van te kijken of de route gemiddeld goed is, kijkt het systeem specifiek naar de gevaarlijkste bochten, leert daar extra veel over, en garandeert dat je nergens in een ravijn belandt. Het combineert slimme zoektochten naar fouten met wiskundige "zachte" technieken om dit snel en betrouwbaar te doen.

Het resultaat is een AI-model dat niet alleen snel is, maar waarvan we wiskundig zeker weten dat het veilig blijft, zelfs in het slechtst denkbare scenario.

Titel: Worst-case Nonlineaire Regressie met Foutgrenzen

Auteur: Alberto Bemporad (IMT School for Advanced Studies, Lucca, Italië)
Datum: April 2026

1. Probleemstelling

In de regeltechniek en systeemidentificatie is het vaak noodzakelijk om complexe niet-lineaire functies (zoals dynamische modellen of modelvoorspellende regeling, MPC) te benaderen door eenvoudigere surrogate-modellen, zoals feedforward neurale netwerken (NN). De standaardaanpak is het minimaliseren van de gemiddelde kwadratische fout (MSE).

Het centrale probleem dat dit artikel adresseert, is dat een lage MSE niet garandeert dat de worst-case fout (WCE) klein is. Voor robuuste regeltoepassingen, zoals het garanderen van stabiliteit en het voldoen aan constraints, is het echter cruciaal om een gegarandeerde bovengrens te hebben op de maximale afwijking tussen het ware model en de benadering over het hele invoergebied. Bestaande methoden bieden vaak alleen probabilistische garanties of zijn beperkt tot lineaire modellen. Dit artikel richt zich op het direct minimaliseren en kwantificeren van de WCE voor niet-lineaire modellen.

2. Methodologie

De auteur stelt een actief leermethode (active learning) voor die de volgende kerncomponenten combineert:

A. Minimax Regressie met Gladde Benadering

Het doel is om de parameters $\theta$ van een model $\hat{f}$ te vinden die de maximale absolute fout minimaliseren:
$\min_{\theta} \left( r(\theta) + \max_{x \in X} |f(x) - \hat{f}(x; \theta)| \right)$
Omdat de $\max$ -operator niet-glad (nonsmooth) is, wat het gebruik van efficiënte gradient-based methoden (zoals L-BFGS) bemoeilijkt, wordt de niet-gladde operator vervangen door een gladde benadering (Softmax-achtig):
$\max(v) \approx \frac{1}{\gamma} \log \left( \sum e^{\gamma v_i} \right)$
Hierbij is $\gamma$ een parameter die de nauwkeurigheid bepaalt; hoe groter $\gamma$ , hoe dichter de benadering bij de echte $\max$ -waarde komt. Dit maakt het mogelijk om automatische differentiatie en quasi-Newton-methoden te gebruiken.

B. Actief Leeren (Active Learning)

Om de afhankelijkheid van de trainingsset te minimaliseren en de WCE over het hele domein te garanderen, wordt een iteratieve strategie gebruikt:

Start met een initiële dataset.
Train het model om de gladde $\ell_\infty$ -fout te minimaliseren.
Gebruik globale optimalisatie om het punt $x^*$ te vinden waar de huidige fout $|f(x) - \hat{f}(x)|$ maximaal is.
Voeg dit punt (en de ware waarde $f(x^*)$ ) toe aan de trainingsset.
Herhaal tot de fout onder een drempelwaarde $\epsilon_{err}$ ligt of het rekenbudget op is.

C. Kwantificering van Foutgrenzen

Na het trainen worden niet alleen uniforme grenzen berekend, maar ook:

Asymmetrische grenzen: Splitsing in een onder- en bovengrens.
Invoer-afhankelijke grenzen: Het leren van een "envelope"-functie (een NN) die de lokale fout nauwkeuriger schat dan een constante waarde.
Garantie: De methode levert een gegarandeerde bovengrens op, mits de globale optimalisatie voldoende nauwkeurig is uitgevoerd (onder Lipschitz-aannames).

D. Toepassingen op Constraints en Sets

De methode wordt uitgebreid om:

Constraints te respecteren: Zorgen dat een vereenvoudigde constraint $\bar{f}(x) \leq 0$ impliceert dat de ware constraint $f(x) \leq 0$ geldt (voor conservatieve benaderingen).
Sets te benaderen: Convexe binnenbenaderingen van niet-convexe sets te leren.
MPC te benaderen: Expliciete MPC-wetten te vervangen door NN's met gegarandeerde foutgrenzen.

3. Belangrijkste Bijdragen

Gladde $\ell_\infty$ -optimalisatie: Een techniek om niet-gladde minimax-problemen op te lossen met standaard gradient-based optimizers.
Actief Leeren voor WCE: Een strategie die globale optimalisatie gebruikt om "corner cases" (punten met maximale fout) actief toe te voegen aan de dataset, in plaats van te vertrouwen op willekeurige steekproeven.
Gegarandeerde Foutgrenzen: Methoden om zowel constante als invoer-afhankelijke foutgrenzen te berekenen die gelden over het volledige compacte invoergebied.
Python Library: De implementatie is beschikbaar als open-source bibliotheek maxfit.

4. Resultaten en Numerieke Voorbeelden

De methode is getest op diverse scenario's:

Niet-lineaire functies: Benadering van een Gaussische functie. De resultaten tonen aan dat het minimaliseren van de WCE leidt tot een veel kleinere maximale fout dan het minimaliseren van de MSE, zelfs als de MSE iets hoger is.
Convexe binnenbenadering: Het vinden van een convexe polyhedron of een input-convex NN die een niet-convexe set volledig bevat.
Onzekere discrete-tijdsmodellen: Het leren van een lineair of PWA-model voor een pendulum met wrijving en niet-lineaire stijfheid, inclusief berekening van de additieve onzekerheidsintervallen ( $W$ en $V$ ).
Multiparametrisch QP (mpQP) en MPC:
- Benadering van de oplossing van een mpQP-probleem.
- Implementatie van een geschatte lineaire MPC-regelaar voor een niet-minimum-fase systeem.
- Vergelijking: Een model getraind met MSE-verlies had een WCE van ~0.40, terwijl het actief geleerde minimax-model een WCE van ~0.064 had, met een vergelijkbare MSE. Dit onderstreept dat MSE alleen misleidend kan zijn voor veiligheidskritieke toepassingen.

5. Betekenis en Conclusie

Dit artikel biedt een robuust raamwerk voor het trainen van surrogate-modellen waarbij garanties op de maximale fout centraal staan, in plaats van alleen gemiddelde prestaties. Dit is van cruciaal belang voor:

Robuuste Regeltechniek: Waar modelonduidelijkheden als verstoringen worden behandeld.
Veiligheid: Waar het garanderen van constraint-satisfactie (bijv. in MPC) essentieel is.
Efficiëntie: Het vervangen van complexe online berekeningen (zoals QP-oplossers) door snelle NN's zonder in te boeten aan stabiliteitsgaranties.

De belangrijkste beperking is de schaalbaarheid: de methode vereist globale optimalisatie om de foutgrenzen te vinden, wat rekenkundig intensief wordt naarmate de dimensie van het probleem toeneemt. Desalniettemin biedt het een waardevolle oplossing voor kleine tot middelgrote systemen waar nauwkeurige foutgrenzen vereist zijn.