Zelflerende software: dynamisch optimaliseren en aanpassen

Optimalisatievraagstukken kun je met software in de basis op twee manieren beantwoorden: lineair geprogrammeerd of dynamisch lerend. Wij kozen voor het tweede, in een proof of concept van een installatie die zich naar de zon moet draaien. In dit artikel lees je hoe dat werkt.

Een waterschap vroeg ons mee te denken over sun tracking van drijvende zonnepanelen op basis van real-time beeldanalyse. De software maakt een foto, lokaliseert de zon en bepaalt zo de oriëntatie van de installatie. Dan bedient het de aangesloten aandrijving(en) om de oriëntatie te optimaliseren.

Aandrijving besturen

In de afbeelding zie je hoe de software de orientatie bepaalt, door in een foto de zon te lokaliseren. Vervolgens is het zaak om de installatie zo te sturen dat na afloop de zon zich in het midden van de afbeelding bevindt. Het opzoeken van de zon is in de basis niet moeilijk, hoewel het wel wat testwerk zal vergen om het op alle (Hollandse) scenario’s af te stemmen. Wij gebruikten een methode met opencv.

Een lastigere vraag is: hoe zorg je dat een drijvende installatie zo efficiënt mogelijk naar een vast punt wordt gedraaid? En dan met name: zonder te verzanden in eindeloos heen-en-weer sturen? Hierover gaat dit artikel.

Je zou kunnen testen hoe lang de motor moet draaien om de zon op de foto van x naar y te draaien. Dan wordt de aandrijving een simpele formule met gewenste afstand als input en (kracht, duur) als output. Of je werkt in een feedback loop: start de motor > maak voortdurend foto’s > stop de motor als de gewenste oriëntatie bereikt is.

Maar in beide gevallen mis je de externe invloeden in de praktijk. Omstandigheden die van invloed zijn op het effect van aandrijving, zoals: 

1. windkracht
2. stroming in het water
3. aangroeiing installatie
4. accuvermogen
5. na-draaien (kinetische energie)

Risico van na-draaien

Met name punt 5 is een risico, want daarin komen alle factoren samen. Het effect van na-draaiing wordt beïnvloed door alle overige omstandigheden. Sommige van die omstandigheden zullen fluctueren, zoals de wind en stroming. Andere nemen misschien toe of af, zoals aangroeiing en accuvermogen.

Het risico van na-draaiing is dat de installatie de gewenste oriëntatie voorbijschiet, waarna de software het terug zal stuwen. In een lineaire oplossing is de kans groot dat je dan eindeloos heen-en-weer blijft sturen. Telkens een rem of anker gebruiken is in de beoogde opstelling niet wenselijk.

Zelflerende software

Een manier om hiermee om te gaan, is om de software zelf te laten leren wat in een gegeven situatie (oriëntatie en beweging) de beste aandrijving is. Door telkens de gebruikte aandrijving en de uiteindelijke situatie te ‘scoren’, leert de software steeds beter de juiste aandrijvingsactie te kiezen. Het kan dan bijvoorbeeld leren om op tijd de motoren uit te schakelen of om aan het eind eventjes terug te stuwen.

Dit mechanisme van voorspellen, toepassen en leren is in eerste instantie wat ingewikkelder om te bouwen. En de software zal een leercurve doormaken: het wordt telkens slimmer, maar start ook wel vrij dom. Maar goed opgezet zal de lerende software uiteindelijk in de dynamische praktijk beter presteren dan een lineaire methode, en voortdurend blijven optimaliseren. En door meetbare invloeden zoals wind, stroming , accuvermogen mee te nemen in het leerproces, leert de software op verschillende omstandigheden in te spelen.

Reinforcement Learning: belonen en straffen

Deze vorm van machine learning heet Reinforcement Learning (RL) en is gebaseerd op een eenvoudig principe van feedback en optimalisatie. In de kern komt het erop neer dat de software een actie uitvoert (zoals het aanstuwen van de motor met een bepaalde richting, kracht + duur), daarna het resultaat meet (de nieuwe oriëntatie t.o.v. de zon plus de actuele bewegingssnelheid) en voor dit resultaat een beloning of straf ontvangt.

Door telkens de actie, het resultaat en de bijbehorende beloning te verwerken, leert het RL mechanisme steeds beter om vooraf de beste actie te kiezen. Gegeven een bepaalde staat, kiest of voorspelt het de actie waarvan het aanneemt dat die de hoogste beloning oplevert.

Experimenteren

Om te beginnen met leren -en om te blijven leren- heeft de software wel iets nodig: het moet experimenteren. Dat betekent dat het af en toe niet de best voorspelde actie kiest, maar een (min of meer) willekeurige actie probeert. Als je immers altijd maar blijft doen wat je kent, ontdek je nooit of er een betere manier bestaat. Gebruikelijk is om software in het begin heel vaak te laten experimenteren, en het aantal experimenten gradueel te laten afnemen naarmate het meer ervaring krijgt.

Onze proof of concept installatie is een robot die zichzelf naar de ‘zon’ (in dit geval een lamp) richt. De software weet maar twee dingen: hoe het de aandrijving bestuurt en hoe het de oriëntatie bepaalt. We belonen elke actie op basis van de uiteindelijke oriëntatie en het aantal bewegingen dat daarvoor nodig was. Eén beweging naar de perfecte oriëntatie levert de hoogste beloning op.

Het resultaat zie je in onderstaande grafiek, die het aantal benodigde bewegingen laat zien in de eerste 1000 pogingen.

Hierin is duidelijk zichtbaar dat in het begin veel ’tegensturen’ nodig is, en dat soms wel 4 tot 7 bewegingen nodig zijn. Maar al na dik 100 pogingen neemt het aantal bewegingen af. Na ruim 200 pogingen zijn ooit meer dan twee bewegingen nodig en gaandeweg lukt het steeds vaker om in één beweging naar de juiste oriëntatie te sturen.

Hieronder zie je de installatie in actie. Je ziet eerst tweemaal hoe de installatie in één beweging de juiste oriëntatie vindt. Daarna een stukje van hoe de installatie begint met leren.