9 September 2026 –
Een recent gesprek met een wolvenspotter brengt me op een nieuw idee. We praten over het volgen registreren en documenteren van wolven en over de techniek die daarbij wordt gebruikt. Wildcamera’s kunnen prima vastleggen wat er door een gebied loopt, maar wat als ik zo’n camera intelligenter maak? Kan ik een wolf automatisch herkennen en die detectie vervolgens gebruiken om binnen een afgebakend gebied mobiel gericht actie te ondernemen?
Er bestaan al systemen die een deel hiervan doen. Een wildcamera reageert op beweging, maakt een foto en stuurt die via 4G naar een server. Een AI-model bepaalt daar of er een wolf op staat en stuurt bij een positieve detectie een waarschuwing. Ik wil het anders aanpakken. Ik wil de complete herkenning lokaal uitvoeren, zonder dat er een foto naar een server hoeft. De camera levert het beeld en de computer ernaast bepaalt zelf of er een wolf voor staat. Alles lokaal op de edge.
Niet zelf trainen, maar DeepFaune gebruiken
Mijn eerste gedachte is om zelf een YOLO-model te trainen. Ik verzamel foto’s van wolven, honden, vossen en andere dieren, annoteer ze en train daarmee een detector. Voordat ik daar veel tijd in steek, kijk ik eerst wat er al bestaat.
Mijn zoektocht brengt me bij DeepFaune, een initiatief van het Franse CNRS voor het automatisch herkennen van Europese fauna op beelden van wildcamera’s. Meer dan honderd partners leveren hiervoor beeldmateriaal aan en samen bouwen ze aan een dataset van meer dan een miljoen geannoteerde beelden. De wolf zit expliciet tussen de dieren die het model kan classificeren.Daarmee verandert mijn aanpak. Ik ga voorlopig helemaal niets trainen, maar onderzoek eerst hoe goed ik met de bestaande modellen wolf van niet-wolf kan onderscheiden.
DeepFaune verdeelt dat over twee stappen. Eerst zoekt een detector waar er dieren in de foto staan. Voor ieder gevonden dier krijg ik een bounding box terug en maak ik een crop. Alleen die crop gaat vervolgens naar de classifier, die bepaalt om welke soort of soortgroep het gaat.Voor mijn eerste opstelling gebruik ik de modellen via PyTorch-Wildlife. De detectie is gebaseerd op YOLOv8 en voor de classificatie gebruikt DeepFaune een DINOv2 vision transformer. Mijn wolfdetector wordt daarmee een vrij overzichtelijke keten: foto inladen, dier detecteren, uitsnijden, classificeren en uiteindelijk beslissen: wolf of geen wolf?
YOLOv8 bepaalt eerst waar het dier staat. Alleen het uitgesneden dier gaat daarna naar DeepFaune voor de soortclassificatie.
Eerst lokaal op mijn laptop
Ik begin bewust niet met embedded hardware. Eerst wil ik de complete softwareketen lokaal aan de praat krijgen. Ik maak in PyCharm een Python 3.10-project en bouw daar mijn eerste versie omheen. De code staat relatief snel, maar daarna begint het bekende dependencywerk. Windows 11 Smart App Control blokkeert een DLL van PyTorch. Vervolgens ontbreken onder andere opencv-python en soundfile, en uiteindelijk blijkt mijn versie van setuptools juist te nieuw. Terugpinnen naar setuptools<82 lost het laatste probleem op en daarna laadt de complete keten.
Nu kan ik eindelijk foto’s gaan voeren.Voor ieder gevonden dier teken ik de bounding box terug op de originele afbeelding en plaats ik de classificatie en confidence erboven. Een wolf krijgt een rood kader, alle andere dieren krijgen een groen kader. Rechtsboven voeg ik BotBerg Wolf-Detector 2026 toe, zodat ik de resultaten gemakkelijk kan vergelijken.Tijdens die eerste tests ontdek ik ook hoe DeepFaune zijn labels teruggeeft. Een paard wordt bijvoorbeeld niet als horse, maar als equid geclassificeerd: de hogere taxonomische groep van de paardachtigen. Voor mijn toepassing is dat prima. Ik hoef niet ieder dier perfect op soort te herkennen, zolang een niet-wolf maar geen wolf wordt.
De eerste wolf
Dan voer ik een frontale foto van een wolf in. YOLO vindt het dier, ik maak de crop en stuur die naar DeepFaune. De classifier geeft wolf terug met een confidence van vrijwel 100 procent. Mijn software tekent het kader rood en daarmee werkt de hele keten voor het eerst van begin tot eind.
Een duidelijke wolf als wolf herkennen zegt alleen nog weinig. Daarom maak ik een kleine testset met meerdere wolven, een wild zwijn, een paard en een husky. Ik voeg daarnaast bewust een paar vreemde beelden toe om te zien wat er gebeurt wanneer DeepFaune iets voorgeschoteld krijgt dat buiten zijn normale toepassingsgebied valt.
Bij een foto met meerdere wilde zwijnen zie ik mooi waarom de tweestapsaanpak werkt. YOLO vindt de dieren afzonderlijk en maakt voor ieder dier een eigen crop. DeepFaune classificeert die vervolgens onafhankelijk als wild boar. Het maakt dus niet uit of er één of meerdere dieren voor de camera staan.
Wolf of husky?
De husky vind ik een veel belangrijkere test. Een systeem dat een duidelijke wolf herkent is leuk, maar als iedere loslopende husky vervolgens een wolvenalarm veroorzaakt heb ik er weinig aan.
Ik voer daarom een husky in. DeepFaune geeft dog terug met 99,96 procent confidence. De wolf-score is praktisch nul en mijn software tekent dus netjes een groen kader.
Nog interessanter wordt het wanneer ik een foto gebruik waarop zowel een husky als een wolf staat. De detector vindt beide dieren en stuurt twee afzonderlijke crops naar de classifier. De ene komt terug als dog, de andere als wolf. In dezelfde foto staat daarmee een groen kader om de husky en een rood kader om de wolf.
Beide worden afzonderlijk gedetecteerd en correct geclassificeerd. Dat is precies het onderscheid waar ik naar zoek.
Kijken hoe het fout gaat
Daarna voer ik bewust een giraffe in. Die hoort niet bij de Europese fauna waarvoor ik DeepFaune gebruik en ik verwacht dus geen goede classificatie. Het model maakt er equid van, maar slechts met ongeveer 26 procent confidence.
De classificatie is fout, maar juist die lage confidence is nuttig. Het laat zien dat ik in mijn eigen software nooit alleen naar het label moet kijken. Een regel als if prediction == "wolf" is te simpel. Ook de zekerheid waarmee het model tot dat oordeel komt moet onderdeel zijn van de beslissing.
maar de lage confidence maakt die onzekerheid direct zichtbaar.
Van losse foto naar sequence
Een wildcamera maakt bij beweging meestal meerdere foto’s kort achter elkaar. Ik gebruik die beelden daarom als één sequence in plaats van volledig losse waarnemingen. Iedere foto gaat afzonderlijk door de detector en classifier, maar pas daarna neem ik een beslissing over de complete gebeurtenis.
Mijn eerste test bestaat uit negen beelden verdeeld over vier sequences. Twee sequences bevatten daadwerkelijk een wolf. Na verwerking meldt mijn script 2/4 sequence(s) als wolf gemarkeerd. Dat zijn precies de juiste twee. De husky, het wild zwijn en de beelden met lage confidence veroorzaken geen wolfmelding.
Twee van de vier testsequences bevatten een wolf en precies die twee worden gemarkeerd. Negen beelden zijn natuurlijk veel te weinig om iets te zeggen over de werkelijke betrouwbaarheid. Daarvoor heb ik straks veel meer materiaal nodig: dag- en nachtbeelden, verschillende hondenrassen, gedeeltelijk zichtbare dieren, verschillende camerahoeken en slechte weersomstandigheden. Voor deze fase wil ik vooral weten of de technische keten werkt. En.. Dat doet hij.
for path in seq:
img, results = classify_image(path, detector, classifier)
wolf_conf = max(
(r["conf"] for r in results if r["label"].lower() in WOLF_LABELS),
default=0.0,
)
seq_conf = max(seq_conf, wolf_conf)
raw = ", ".join(f"{r['label']}={r['conf']:.2f}" for r in results)
out_path = annotate_and_save(path, img, results)
print(f" {path.name:30s} | {raw}")
print(f" {'':30s} -> {out_path}")
verdict = "WOLF" if seq_conf >= CONF_THRESHOLD else "geen wolf"
total_wolf_seqs += verdict == "WOLF"
print(f" => sequence-oordeel: {verdict} (max conf {seq_conf:.2f})\n")Nu naar de edge
Alles draait nu volledig lokaal op mijn laptop. Geen foto gaat naar een cloudservice. De detectie, crops en classificatie worden allemaal lokaal verwerkt. Mijn laptop wil ik alleen niet aan de rand van een weiland zetten, dus de volgende stap is het verplaatsen van dezelfde software naar embedded hardware.
De YOLOv8-detector vormt daarbij waarschijnlijk niet het grootste probleem. De DeepFaune-classifier is zwaarder. Die gebruikt een DINOv2 ViT-Large vision transformer en op mijn Intel Core Ultra 7 155U merk ik dat: classificatie kost seconden in plaats van milliseconden.
Daarom kijk ik met een schuin ook al naar een NVIDIA Jetson Orin Nano als doelplatform. Ik hoef de zware classifier bovendien niet continu te draaien. Zolang er geen dier voor de camera staat, valt er niets te classificeren. De lichte detector kan als eerste filter dienen en alleen wanneer die een dier vindt, start ik DeepFaune.
Dat maakt de benodigde rekenkracht een stuk realistischer. Ik probeer geen complete videostream continu op soortniveau te classificeren. Ik wil alleen snel genoeg reageren wanneer er daadwerkelijk een dier verschijnt.
Detecteren is pas het begin
Tijdens het uitzoeken kom ik ook een onderzoek van Hajder en collega’s uit 2025 tegen waarin een vergelijkbare combinatie van wolfdetectie, YOLOv8 en een Jetson Orin Nano wordt gebruikt. Daar komt een volgend probleem naar voren dat voor mijn project misschien nog interessanter is dan de detectie zelf: gewenning.
Als ik na iedere wolfdetectie exact hetzelfde alarm laat horen, leert het dier uiteindelijk dat er na dat geluid niets gebeurt. Daarom wil ik uiteindelijk niet één vaste afschrikactie aan de detector koppelen, maar verschillende stimuli waarvan het systeem de effectiviteit bijhoudt. Werkt een stimulus niet meer, dan moet het systeem een andere kiezen.
Wolf gedetecteerd → stimulus kiezen → reactie waarnemen → effectiviteit aanpassen → volgende keuze
Dat wordt een volgende stap. Voor nu weet ik wat ik wilde weten: ik hoef geen eigen wolfmodel vanaf nul te trainen. Met YOLOv8, DeepFaune en PyTorch-Wildlife kan ik lokaal een wolf herkennen, een husky juist als hond classificeren en meerdere waarnemingen combineren voordat ik een wolfmelding geef.
Meer dan alleen wolven
De combinatie van YOLOv8 en DeepFaune is natuurlijk voor veel meer te gebruiken dan alleen mijn wolfdetector. YOLOv8 is vooral interessant zodra ik in camerabeelden automatisch iets wil vinden, tellen of volgen: mensen of voertuigen rond een terrein, producten op een transportband, onderdelen in een machine, bezette parkeerplaatsen of dieren die een bepaald gebied binnenkomen. DeepFaune voegt daar specifiek de herkenning van Europese fauna aan toe. Daarmee kan ik bijvoorbeeld een slimme wildcamera maken die automatisch bijhoudt welke dieren langskomen, reeën of wilde zwijnen tellen, activiteit per tijdstip registreren of alleen beelden van een bepaalde diersoort bewaren. De twee modellen hoeven daarbij ook niet altijd samen te werken: YOLOv8 kan ik voor allerlei eigen objectdetectieprojecten trainen, terwijl DeepFaune juist interessant is wanneer de vraag niet alleen waar staat een dier? is, maar ook welk dier is het? Daarmee is de Wolf-Detector voor mij meteen een mooie kennismaking met een AI-pipeline die ik later ook in heel andere BotBerg-projecten kan hergebruiken.
Tijd om AI poten te geven
De software werkt. Nu moet hij van mijn laptop af. Als volgende stap zet ik de Wolf-Detector op edge-hardware en geef ik hem een camera, zodat hij zelfstandig mee naar buiten kan. Maar daar wil ik niet stoppen. Wat gebeurt er als ik diezelfde hardware vervolgens op een mobiele robot zet? Dan bouw ik niet langer alleen een wolfdetector, maar een systeem dat een wolf kan herkennen, erop kan reageren én van positie kan veranderen. Tijd om de AI poten te geven.
Waarom ik dit soort projecten leuk vind
Dit soort projecten vind ik leuk omdat er meerdere werelden bij elkaar komen. Ik begin met een praktische vraag, duik in technieken die voor mij soms nog nieuw zijn en bouw daar stap voor stap iets werkends van. Hier komen AI, beeldherkenning, Python, edge-computing en uiteindelijk ook elektronica en robotica samen. Juist het experimenteren, problemen oplossen en ontdekken wat ik met bestaande technieken zelf kan bouwen, maakt dit soort projecten voor mij zo leuk.
Wordt vervolgd.