Wat is Julia?
Julia is een relatief nieuwe programmeertaal die voor het eerst werd uitgebracht in 2012. Hoewel Julia pas tien jaar bestaat, groeit de taal razendsnel en staat hij nu in de top 30 programmeertalen volgens de TIOBE-index van oktober 2022.
Een opvallende eigenschap van Julia is dat het is gebouwd voor wetenschappelijk rekenen. Dat betekent dat Julia zowel gebruiksvriendelijk als snel is, en tegelijkertijd in staat is om grote hoeveelheden data en complexe berekeningen razendsnel te verwerken. Een bekende slogan van Julia is dat het "draait als C maar leest als Python".
Julia is een gecompileerde taal die leest als een geïnterpreteerde taal. De meeste andere traditionele gecompileerde talen (zoals C of C++) die rekenintensieve problemen kunnen oplossen, moeten eerst naar een machineleesbaar formaat worden gecompileerd voordat ze uitgevoerd kunnen worden.
Julia kan daarentegen dezelfde prestaties behalen met de eenvoud van een geïnterpreteerde taal (zoals Python), maar zonder vooraf te hoeven compileren. In plaats daarvan gebruikt Julia een Just-In-Time-compiler (JIT) die compileert tijdens het uitvoeren.
Waarom kiezen voor Julia voor machine learning?
Python domineert al lange tijd het data science- en machine learning-landschap, en met goede reden. Het is een enorm krachtige, flexibele programmeertaal. Toch zijn er enkele nadelen van Python die in Julia geen rol spelen.
Enkele nadelen van Python vergeleken met Julia zijn:
- Python is een tragere, geïnterpreteerde taal met beperkte opties om de snelheid te verbeteren. Dit kan big data-machinelearningprojecten minder efficiënt maken dan in Julia.
- Python gebruikt single dispatch, wat een aanzienlijke beperking oplegt aan de types die gebruikt en gedeeld kunnen worden tussen functies en libraries.
- Parallel computing en threading zijn niet ingebouwd in het ontwerp van de Python-taal. Er zijn wel libraries die enige threading mogelijk maken, maar dit is niet optimaal.
In deze sectie bespreken we verschillende redenen waarom Julia een uitstekende keuze is voor machine learning.
Je kunt je verder verdiepen in de opkomst van de taal en of Julia het waard is om te leren in 2022 in een apart blogartikel.
1. Eenvoud & gebruiksgemak
Julia heeft een zeer vriendelijke syntaxis die dicht bij het Engels ligt. Daardoor leer je de taal veel sneller, omdat de code vaak intuïtief en makkelijk te begrijpen is.
Julia is ook snel en eenvoudig te installeren, zodat je direct aan de slag kunt. Je hoeft geen speciale distributies van de taal te installeren (zoals bij Python en Anaconda) of een ingewikkeld installatieproces te volgen (zoals bij C en C++).
Voor machine learning-practitioners geldt: hoe sneller je de frictie in het programmeerwerk wegneemt, hoe sneller je kunt doen waar je goed in bent: data analyseren en modellen bouwen.
2. Snelheid
Een van Julia’s grootste troeven is de snelheid. We noemden hierboven al dat Julia een gecompileerde taal is, wat aanzienlijke snelheidswinst oplevert ten opzichte van geïnterpreteerde talen.
Julia behoort tot de "petaflop club" samen met C, C++ en Fortran. Inderdaad, deze exclusieve club heeft slechts vier leden en één toelatingseis: piekprestaties van één petaflop (dus één duizend biljoen operaties) per seconde behalen.
In machine learning kom je vaak grote hoeveelheden data tegen, dus het gebruik van een snelle programmeertaal kan de trainingstijden aanzienlijk verbeteren en de kosten verlagen bij het uitrollen van modellen naar productie.
3. Degevectoriseerde code is snel
In Julia is het niet nodig om code te vectoriseren om de prestaties te verhogen. Degevectoriseerde code schrijven in de vorm van lussen en native functies is al snel. Code vectoriseren kan in Julia een kleine snelheidswinst opleveren, maar is niet nodig.
Werken met degevectoriseerde code kan je veel tijd besparen bij het bouwen van machinelearningmodellen, omdat je code niet hoeft te refactoren om sneller te worden.
4. Hergebruik van code & multiple dispatch
Julia gebruikt duck-typing om het juiste type voor een functie te ‘raden’. Dit betekent: als het loopt als een eend en kwaakt als een eend, is het waarschijnlijk een eend. Elk object dat voldoet aan de impliciete specificaties van een functie wordt dus ondersteund — je hoeft het niet expliciet te specificeren.
Duck-typing is echter niet altijd geschikt voor speciale gevallen, en daar komt multiple dispatch om de hoek kijken. Met multiple dispatch kun je meerdere speciale gevallen voor een functie definiëren, en afhankelijk van welke voorwaarden worden vervuld, kiest de functie tijdens het uitvoeren de meest geschikte optie.
Multiple dispatch is nuttig in machine learning omdat je niet aan elk mogelijk type hoeft te denken dat aan een functie mag worden doorgegeven. Pakketten in Julia kunnen daardoor zeer flexibel blijven en toch code en types delen tussen verschillende pakketten.
Denk aan datumformaten: er zijn meerdere pakketten die hun eigen aangepaste datum- en datum/tijdformaten gebruiken. Zo heb je in Python het ingebouwde datetime-formaat en het Pandas-formaat datetime64[ns]. In Julia is er slechts één datumgebaseerd formaat dat door alle pakketten wordt gedeeld via de ingebouwde dates-module.
5. Ingebouwd pakketbeheer
Pakketten worden in Julia automatisch beheerd met Pkg. Pkg is voor Julia wat Pip is voor Python, maar dan beter. Omgevingen worden in Julia beheerd via twee bestanden: Project.toml en Manifest.toml. Deze bestanden vertellen Julia welke pakketten in het project worden gebruikt en welke versies. In plaats van speciale omgevingen extern te definiëren, wordt de maplocatie van je Julia-bestanden (met de Project- en Manifest-toml-bestanden) de omgeving.
Dit soort ingebouwde, vereenvoudigde aanpak van pakketbeheer maakt het makkelijker om je machinelearningprojecten en analyses te delen en te reproduceren.
6. Het twee-talenprobleem
Wist je dat slechts 20–30% van de Python-pakketten daadwerkelijk uit Python-code bestaat?
Die afhankelijkheid van andere talen komt doordat pakketten, om efficiënt en doeltreffend te zijn, gebouwd moeten worden in low-level-talen zoals C en C++.
In wetenschappelijk rekenen omvat het ontwikkelen van oplossingen en pakketten meestal twee programmeertalen: de gemakkelijk te gebruiken prototypetaal (zoals Python) om snel een eerste implementatie te bouwen, en vervolgens de snelle taal (zoals C++) waarin alle code wordt herschreven voor de definitieve versie.
Zoals je je kunt voorstellen, is dit een traag, inefficiënt proces — niet alleen voor de initiële ontwikkeling, maar ook voor langetermijnonderhoud en nieuwe features.
In Julia kunnen pakketten daarentegen geprototyped, ontwikkeld en onderhouden worden in Julia. Daardoor wordt de gehele ontwikkelcyclus teruggebracht tot een fractie van de tijd.
Julia-machinelearningpakketten
Julia bevat nu meer dan 7.400 pakketten in het algemene register. Dat is weliswaar ver verwijderd van de enorme hoeveelheid pakketten in Python (meer dan 200.000), maar het kan nog steeds een uitdaging zijn om het juiste pakket te vinden voor een specifiek probleem.
In deze sectie verkennen we de belangrijkste pakketten die je nodig hebt om data te analyseren en machinelearningmodellen te bouwen.
Maar als je net begint met machine learning in Julia, probeer dan eerst de pakketgereedschapskist: MLJ. Dit pakket is speciaal ontwikkeld om de populairste machinelearningpakketten te bundelen op één, makkelijk toegankelijke plek, zodat je tijd bespaart bij het zoeken naar het beste pakket voor je project. MLJ ondersteunt momenteel meer dan 20 verschillende machinelearningpakketten.
Hieronder vind je een lijst met enkele van de meest voorkomende pakketten die je tegenkomt in machinelearningprojecten — van het importeren, opschonen en visualiseren van data tot het bouwen van modellen:
- Notebook: Pluto, IJulia, Jupyter
- Pakket-/omgevingsbeheer: Pkg
- Data importeren en verwerken: CSV, DataFrames
- Plotten en output: Plots, StatsPlots, LaTeXStrings, Measures, Makie
- Statistiek en wiskunde: Random, Statistics, LinearAlgebra, StatsBase, Distributions, HypothesisTests, KernelDensity, Lasso, Combinatorics, SpecialFunctions, Roots
- Individuele machinelearningpakketten:
- Gegeneraliseerde lineaire modellen (bijv. lineaire regressie, logistische regressie): GLM
- Deep learning: Flux, Knet
- Supportvectormachines: LIBSVM
- Beslisboom, random forest, AdaBoost: DecisionTree
- K-nearest neighbors: NearestNeighbors
- K-means-clustering: Clustering
- Hoofdcomponentenanalyse: MultivariateStats
Er zijn ook veel implementaties en wrappers beschikbaar voor populaire Python-pakketten zoals Scikit-Learn en Tensorflow. Je hoeft deze pakketten echter niet per se te gebruiken, want je kunt dan veel van de krachtige voordelen van Julia (zoals snelheid en multiple dispatch) mislopen.
Aan de slag met Julia voor machine learning
Een van de beste manieren om te beginnen met Julia is de Pluto-notebookomgeving. In deze sectie bespreken we de voordelen van Pluto, vooral aan het begin van je data science-reis wanneer je nog leert hoe je machinelearningprojecten met Julia opzet. We behandelen ook enkele van de beste bronnen om meer te leren over Julia en machine learning.
Pluto
Pluto is een gebruiksvriendelijke, interactieve notebookomgeving met een prettige interface. Deze eenvoud maakt het zeer geschikt voor beginners die met Julia starten. Pluto heeft bovendien veel extra functies waarmee je bijna moeiteloos nog overtuigendere machinelearningsoplossingen kunt bouwen:
Reactiviteit
Bij het uitvoeren van één cel kijkt Pluto ook welke andere cellen uitgevoerd moeten worden. Zo worden alle afhankelijke cellen bijgewerkt voordat de huidige cel wordt geëvalueerd.
Het mooie aan Pluto is dat het slim genoeg is om precies te bepalen welke cellen, naast de huidige, nodig zijn. Zo voorkom je dat je elke cel moet bijwerken als je ergens in je notebook iets wijzigt.
Pluto ruimt ook oude of verwijderde code op en werkt de output van afhankelijke cellen bij om dit te weerspiegelen. Als je een variabele in één cel definieert en die cel later verwijdert, verwijdert Pluto die variabele ook uit zijn namespace. Bovendien tonen afhankelijke codecellen een foutmelding om aan te geven dat de benodigde variabele nu is verwijderd.
Interactiviteit
Reactiviteit zorgt voor automatische interactiviteit tussen cellen. Dit is vooral handig om snel interactieve grafieken of objecten te maken die automatisch worden bijgewerkt wanneer een variabele verandert.
Het mooie aan Pluto is dat die variabele een interactieve widget in het notebook kan zijn, zoals een ingebouwde slider of tekstvak. Als je Javascript kent, kun je zelfs je eigen widgets ontwerpen.
Reactiviteit en interactiviteit stellen je in staat dynamische rapporten en dashboards te maken op basis van je machinelearningmodellen en data-analyses. De sleutel tot een succesvol machinelearningproject is communicatie, en Pluto maakt het veel makkelijker om je project te demonstreren en uit te leggen.
Automatisch pakketbeheer
Pluto integreert naadloos met Pkg voor automatisch pakketbeheer in je notebooks. Sterker nog, je hoeft pakketten niet buiten Pluto te installeren. Alle informatie die Pluto (en Julia) nodig heeft om je notebook uit te voeren en te reproduceren, staat gewoon in het notebook zelf!
Dit betekent dat je je notebook kunt delen met collega’s of klasgenoten, en zeker weet dat alle juiste pakketten die het notebook nodig heeft om te draaien, worden meegeleverd.
Versiebeheer
Alle Pluto-notebooks worden opgeslagen als uitvoerbare .jl-bestanden. Als je een notebook in een teksteditor opent, ziet het er iets anders uit dan in je browser. Het bestand bevat alle informatie die het notebook nodig heeft, zoals de code, de afhankelijkheden tussen cellen en de uitvoervolgorde. Deze bestanden bevatten echter geen output. Dit alles maakt versiebeheer met Git en GitHub veel eenvoudiger.
Exporteren & delen
Pluto-notebooks kunnen worden geëxporteerd als een uitvoerbaar .jl-bestand, een statische pdf of een statisch HTML-bestand. Als je exporteert naar HTML, krijgt de ontvanger ook de optie om het ruwe notebookbestand te downloaden en te bewerken zonder dat Julia op zijn of haar machine is geïnstalleerd.
Pluto realiseert dit via een samenwerking met Binder — een gratis platform dat Pluto-notebooks online host (het werkt ook met andere programmeertalen, zoals Python en R).
Deze functionaliteit is de laatste stap in een machinelearningworkflow: eerst voer je je analyses uit, daarna bouw je in je notebook een interactief rapport om de resultaten te tonen, en tot slot kun je het notebook delen met technische collega’s, die de analyse kunnen reproduceren en bewerken, én met niet-technische betrokkenen.
Bronnen om Julia te leren
Dit zijn enkele van de meest aanbevolen bronnen om te leren over de programmeertaal Julia en hoe je die inzet voor data science en machine learning:
- Als je graag leert in een interactieve omgeving, hebben we een cursus Introduction to Julia
- Voor een uitgebreide uitleg van de programmeertaal Julia is het boek Think Julia: How to Think Like a Computer Scientist een van de beste bronnen.
- Bekijk onze beginners-Julia-tutorial voor een stapsgewijze handleiding om met Julia te beginnen
- Zie ons spiekbriefje voor een handig overzicht van de essentials van Julia-programmeren.
