Mojo Language: de nieuwe programmeertaal voor AI

Mojo is een programmeertaal die het gebruiksgemak en de flexibiliteit van dynamische talen, zoals Python, combineert met de performance en controle van systeemtalen als C++ en Rust.

De hoge prestaties worden bereikt met innovatieve compilertechnologieën, zoals geïntegreerde caching, multithreading en clouddistributie, terwijl autotuning en metaprogrammering codeoptimalisatie voor diverse hardware mogelijk maken.

De belangrijkste kenmerken van Mojo zijn:

• Python-achtige syntaxis en dynamische typering maken Mojo eenvoudig te leren voor Python-ontwikkelaars, omdat Python de belangrijkste programmeertaal is achter moderne AI/ML-ontwikkelingen.
• Met Mojo kun je elke Python-bibliotheek importeren en gebruiken, wat volledige interoperabiliteit met Python garandeert.
• Het ondersteunt zowel just-in-time (JIT) als ahead-of-time (AOT) compilatie. De Mojo-compiler past geavanceerde optimalisaties toe en genereert zelfs GPU/TPU-code.
• Mojo geeft volledige controle over geheugenindeling, concurrency en andere low-level details.
• Door dynamische en systeemtaal-capaciteiten te combineren, volgt Mojo een verenigd programmeermodel dat beginnersvriendelijk is en schaalbaar voor uiteenlopende use-cases op basis van accelerators.

Mojo is momenteel een onvolledige taal en nog niet publiek beschikbaar. De documentatie is gericht op ontwikkelaars met ervaring in systeemprogrammering.

Naarmate de taal groeit, is het echter de bedoeling dat deze gebruiksvriendelijker wordt en toegankelijker voor beginnende programmeurs.

Aan de slag met Mojo Lang

Mojo is niet openbaar beschikbaar, maar je kunt toegang krijgen tot Mojo Playground door je aan te melden voor Modular Products. Zorg er tijdens het aanmelden voor dat je Mojo selecteert bij Modular Product Interest.

Afbeelding van Modular: Ga vandaag nog aan de slag

Na aanmelding ontvang je binnen een uur een e-mail die je toegang geeft tot de Mojo Playground. De Mojo Playground is een JupyterHub-omgeving waar gebruikers toegang hebben tot dezelfde Mojo-standaardbibliotheek. Gebruikers hebben echter een privévolume om hun Mojo-programma’s te schrijven en op te slaan.

Afbeelding van Mojo Playground

Wanneer Mojo open-source en publiek beschikbaar wordt, kun je een Mojo-programma vanuit een terminal draaien. Het is zowel een geïnterpreteerde als gecompileerde taal.

Je kunt het bestand opslaan als test.mojo of test.🔥.

Ja, je kunt je bestand opslaan met de vlam-emoji. Zoals je ziet hebben we een eenvoudig Mojo-bestand test.🔥 gemaakt en het in de terminal uitgevoerd.

def main():
    print("Hello Mojo!")Mogelijk gemaakt door

$ mojo test.🔥
Hello Mojo!
Mogelijk gemaakt door

Mojo Lang en Python

Mojo is een superset van Python en heeft een bijna vergelijkbare syntaxis met Python. Het introduceert ook nieuwe features zoals let, var, struct en fn om variabelen, structuren en functies te definiëren en zo de prestaties te verbeteren.

let- en var-declaraties

Bij het schrijven van Mojo-code kun je specifieke variabelen declareren met de sleutelwoorden let en var. Dit lijkt op hoe je variabelen in Rust declareert.

Het sleutelwoord let geeft aan dat een variabele onveranderlijk is, terwijl var aangeeft dat deze gewijzigd kan worden. Dit verbetert de prestaties door beperkingen al tijdens het compileren af te dwingen.

struct-typen

Mojo gebruikt het sleutelwoord struct, dat lijkt op de class in Python. Klassen in Python zijn dynamisch en traag; struct-typen lijken meer op die in C/C++ en Rust. Ze hebben vaste geheugenindelingen die tijdens het compileren worden bepaald, wat ze optimaliseert voor machine-native performance.

fn-definities

Met def definieer je een Python-functie, met alle dynamiek en flexibiliteit die bij Python horen. Het sleutelwoord fn daarentegen definieert een Mojo-functie met meer restricties. Dat betekent onder meer dat argumenten standaard immutabel zijn en dat expliciete types en declaraties van lokale variabelen vereist zijn.

Voorbeeld syntaxisvergelijking

In het voorbeeld maken we een Mojo-functie die twee argumenten optelt.

Om de Mojo-functie te draaien:

• Moet je een type opgeven voor de argumenten van de functie.
• Moet je het retourtype aangeven met een pijl.

fn add(x: Int, y: Int) -> Int:
    return x + y

z = add(3, 5)
print(z)
>>> 8Mogelijk gemaakt door

Bij programmeren in Python kunnen we functies definiëren zonder het argument- en outputtype expliciet te vermelden. Dat maakt het proces dynamischer en eenvoudiger. In vergelijking daarmee is Mojo’s fn-functie echter sneller dan def.

def add(x, y):
    return x + y

z = add(3, 5)
print(z)
>>> 8Mogelijk gemaakt door

Matplotlib in Mojo

Mojo verhoogt niet alleen de performance, maar stelt ontwikkelaars ook in staat om elke Python-bibliotheek te importeren en te integreren met Mojo-functies. Door de CPython-interpreter te gebruiken, ondersteunt Mojo naadloos alle huidige Python-modules.

In het volgende voorbeeld importeren we matplotlib.pyplot en visualiseren we een lijngrafiek. Voor geavanceerde voorbeelden, bekijk Mandelbrot in Mojo.

from PythonInterface import Python

let plt = Python.import_module("matplotlib.pyplot")

x = [1, 2, 3, 4]
y = [30, 20, 50, 60]
plt.plot(x, y)
plt.show()Mogelijk gemaakt door

Het is algemeen bekend dat Python de populairste taal is voor AI/ML. Met het carrièrepad Machine Learning Scientist with Python ontwikkel je de Python-vaardigheden die je nodig hebt om als machine learning scientist aan de slag te gaan.

Programmeren met Mojo Lang

Mojo is een superset van Python, net zoals TypeScript een superset van JavaScript is. Afgezien van nieuwe sleutelwoorden en functies kan elke Python-programmeur het begrijpen en ermee bouwen.

In dit deel bekijken we programmeerfuncties van Mojo die het performant en veilig maken.

Low-level programmeren

Mojo is een high-level programmeertaal die toegang geeft tot low-level primitives via MLIR (Multi-Level Intermediate Representation), een uitbreidbaar intermediate-representatieformaat. Hierdoor kunnen Mojo-programmeurs zero-cost abstractions implementeren en toch krachtige compileroptimalisaties benutten.

Tiling-optimalisatie en autotune

Mojo heeft een ingebouwde tiling-optimalisatietool die de cache-localiteit en geheugen-toegangspatronen verbetert door berekeningen op te delen in kleinere tiles die in het snelle cachegeheugen passen.

De Autotune-module in Mojo biedt interfaces voor adaptieve compilatie. Deze helpt je de beste parameters voor je doelhardware te vinden door je code automatisch af te stemmen.

Ownership en borrowing

Mojo gebruikt het ownership- en borrowing-systeem om geheugen te beheren, waardoor een garbage collector overbodig is en consistente runtime-prestaties worden gegarandeerd. De compiler van Mojo analyseert via statische analyse de levensduur van variabelen en geeft data vrij zodra deze niet meer gebruikt worden.

Handmatig geheugengebeheer

Mojo biedt ook een handmatig beheersysteem met pointers, vergelijkbaar met C++ en Rust.

Matrixvermenigvuldiging in Mojo

In het voorbeeld Matrixvermenigvuldiging zagen we dat het importeren van Python-code in Mojo leidde tot een prestatieverbetering van 17,5 keer.

Door types toe te voegen aan de Python-implementatie werd de performance nog verder verhoogd, met maar liefst 1866,8 keer.

Daarnaast werden technieken zoals vectorization, parallelization, tiling en autotuning toegepast om een prestatiewinst van 14050,5 keer te behalen. Dit is geweldig. Zelfs Julia en Rust bieden geen optimalisatie op dit niveau.

Mojo Lang codevoorbeeld

In dit auto-voorbeeld maken we een CAR-klasse met Mojo-syntaxis.

1. We maken een CAR-klasse met struct.
2. Initialiseer een muteerbare variabele met var.
3. Stel variabeletype in. ‘speed’ is Float32 en ‘model’ is String. String is geen ingebouwd type, dus dat moeten we importeren.
4. We maken twee initialisatiefuncties, vergelijkbaar met Python maar met de fn-functie. Eén met alleen autosnelheid en één met autosnelheid en automodel.
5. Maak daarna een object met CAR met snelheid 300.
6. Print het model van de auto.

from String import String

struct CAR:
    var speed: Float32
    var model: String

    fn __init__(inout self, x: Float32):
        """Car with only speed"""
        self.speed = x
        self.model = 'Base'

    fn __init__(inout self, r: Float32, i: String):
        """Car with Speed and model"""
        self.speed = r
        self.model = i

my_car=CAR(300)
print(my_car.model)Mogelijk gemaakt door

BaseMogelijk gemaakt door

Zoals je ziet lijken de programmeerstijl en functionaliteit van Mojo op die van Python. Het fungeert als een uitbreiding op Python, met betere prestaties en geheugengebruik. Met Mojo kun je je model snel trainen, snellere modelinference bereiken (zelfs met CPU’s), enorme datasets in seconden analyseren en realtime simuleren.

Je kunt alle codevoorbeelden bekijken in de Modular Docs en ze uitvoeren in een Jupyter-notebook in de playground.

Zal Mojo Python vervangen?

Op dit moment is het lastig om het potentieel van Mojo als algemene programmeertaal te bepalen, vanwege de vroege ontwikkelingsfase en het ontbreken van noodzakelijke features. Wel zou het Python kunnen voorbijstreven bij machine learning- en AI-toepassingen waar hoge performance cruciaal is.

Toch is het onwaarschijnlijk dat Mojo op korte termijn Python volledig zal vervangen als koploper in data science en andere softwaredomeinen.

Mojo is specifiek ontworpen voor machine learning-toepassingen en niet bedoeld voor andere gebieden, zoals webbackends, procesautomatisering of webdesign. Hoewel de ontwikkelaar de mogelijkheden in de toekomst kan uitbreiden, ligt de huidige focus van Mojo op optimalisatie voor machine learning.

Daarnaast is het goed om te weten dat Mojo een beperkte selectie modules en bibliotheken heeft vergeleken met Python, dat profiteert van een grote community van ontwikkelaars die voortdurend nieuwe en betere tools voor AI en datawetenschap maken. Het kan jaren duren voordat Mojo op het niveau van Python zit.

Leer hoe generatieve AI-modellen worden ontwikkeld en welke impact ze op de samenleving hebben met de cursus Generative AI Concepts van DataCamp.

Conclusie

Kortom, hoewel Mojo veelbelovend is als snelle, met Python compatibele taal die is toegespitst op AI/ML, zal het Python op korte termijn waarschijnlijk niet volledig vervangen. Python profiteert van een enorme ecosysteem, community en verankering in data science en ML. In het beste geval wordt Mojo een aanvullende taal naast Python, in te zetten waar snelheid cruciaal is.

In deze tutorial hebben we de features en syntaxis van de programmeertaal Mojo doorgenomen met codevoorbeelden. We hebben ook een vergelijking gemaakt met Python, met aandacht voor performance, syntaxis, functionaliteit en compatibiliteit. Voor wie de basis van AI en Machine Learning wil beheersen, raden we het leerpad Machine Learning Fundamentals with Python aan.