Docker voor data science: een introductie

Stel, je hebt aan een end-to-end machinelearningprobleem gewerkt en de optimale oplossing met de beste modellen gevonden. Maar zodra je je code overdraagt aan het engineeringteam, blijkt dat de code die op jouw machine werkte, niet werkt op hun servers, die misschien een ander besturingssysteem en andere libraryversies hebben.

Ondanks al je zorg en harde werk kan dit frustrerende euvel soms toch optreden. De meeste developers maken dit minstens één keer mee. Wat is dan de oplossing? Daar komt Docker om de hoek kijken. Met Docker definieer je een nauwkeurige en consistente omgeving voor je project, zodat je code soepel draait, ongeacht de onderliggende omgeving of setup.

Deze tutorial introduceert Docker en aanverwante concepten en legt uit waarom het belangrijk is voor data scientists. Verder helpt dit artikel je bij de installatie en laat het met voorbeelden zien hoe je Docker in je volgende project gebruikt. Tot slot leer je de best practices uit de industrie en krijg je antwoord op al je Docker-vragen.

Wat zijn Docker, containers en images?

Docker is een platform om applicaties te bouwen, draaien en distribueren. 

Containers zijn lichte, zelfstandige, uitvoerbare pakketten met alles wat nodig is om een applicatie te draaien: de code, een runtime, libraries, omgevingsvariabelen en configbestanden.

Een Docker image is een read-only bestand met alle instructies om een container te maken. Images worden gebruikt om tijdens runtime nieuwe containers te creëren en te starten.

Docker helpt developers om hun applicaties samen met alle afhankelijkheden te verpakken in een container, die vervolgens op elke machine met Docker kan draaien. 

In zekere zin is het alsof je voor elk project een nieuwe machine krijgt. Je installeert de vereiste pakketten, kopieert de benodigde bestanden naar de machine en draait de scripts. Je kunt deze nieuwe machine ook versturen naar elders. Het is een versimpelde vergelijking, maar je snapt het idee. 

Hoe verschillen Docker-containers van virtual machines?

Nu we containers hebben gedefinieerd, vraag je je misschien af hoe ze verschillen van virtual machines, want beide technologieën laten meerdere geïsoleerde omgevingen op dezelfde fysieke machine draaien. 

Bekijk het architectuurverschil in de onderstaande afbeelding en kijk of je het verschil ziet.

Afbeelding door de auteur

Elke virtual machine is een geïsoleerde omgeving die verschillende besturingssystemen en configuraties kan draaien. Dat betekent ook dat elke VM een volledige kopie van het besturingssysteem nodig heeft, wat veel resources kost. Een gecontaineriseerde applicatie draait daarentegen in een geïsoleerde omgeving zonder een volledige kopie van het besturingssysteem, waardoor ze lichter en efficiënter zijn.

Hoewel virtual machines nuttig zijn, zijn containers doorgaans voldoende en ideaal om applicaties te shippen.

Waarom Docker voor data scientists?

Je vraagt je waarschijnlijk af waarom je als data scientist Docker zou moeten leren. Zijn er niet DevOps-teams die de infrastructuurkant regelen?

Goeie vraag — maar Docker is ook voor data scientists enorm belangrijk, zelfs als er een DevOps-team is. Laten we bekijken waarom Docker zo nuttig is.

Integratie met het DevOps-team 

Een DevOps-team hebben doet niets af aan de voordelen van Docker; het helpt juist de kloof tussen development en operations te overbruggen. Data scientists kunnen hun code met Docker verpakken en aan het DevOps-team overdragen voor deployment en opschalen. Dit ga je waarschijnlijk meemaken in een meer gestructureerd data science-team.

Consistente omgeving & reproduceerbaarheid

Data scientists werken vaak met complexe afhankelijkheden en configuraties die moeten worden ingesteld en onderhouden. De omgeving moet hetzelfde blijven om vergelijkbare resultaten te krijgen. Met Docker kunnen data scientists een consistente omgeving maken en delen met alle benodigde dependencies en configuraties vooraf geïnstalleerd, die anderen gemakkelijk kunnen reproduceren.

Portabiliteit

Docker-containers kunnen draaien op elke omgeving met Docker geïnstalleerd, inclusief laptops, servers en cloudplatforms. Zo verplaats je je werk eenvoudig tussen verschillende omgevingen. 

Resource-isolatie

Docker laat meerdere containers op dezelfde machine draaien, elk met zijn eigen geïsoleerde resources. Dit helpt data scientists hun resources efficiënter te beheren en conflicten met andere applicaties te voorkomen. Als je meerdere ML-projecten hebt, kan deze feature een lifesaver zijn.

Samenwerking mogelijk maken

Met Docker kunnen data scientists hun werk in containers met iedereen delen, ook met remote teams. Samenwerken is cruciaal in teamverband, en Docker verlaagt hierbij de drempel.

De meeste ervaren data scientists zullen beamen dat Docker hen helpt zich te focussen op hun werk zonder zich zorgen te maken over de onderliggende infrastructuur. 

Docker-tutorial: Docker gebruiken voor je volgende project

Nu we de noodzaak van Docker voor een data scientist hebben vastgesteld, gaan we snel aan de slag. Eerst moeten we Docker op onze machine installeren en vertrouwd raken met veelgebruikte commando’s.

Docker installeren op je machine of lokale server

Docker is beschikbaar voor alle grote besturingssystemen, zoals Linux, Windows en Mac. De installatie is eenvoudig en het best beschreven in de officiële documentatie.

• Instructies om Docker te installeren op Linux.
• Instructies om Docker te installeren op Windows.
• Instructies om Docker te installeren op Mac.

Als je je eigen images wilt maken en naar Docker Hub wilt pushen (zoals in enkele onderstaande commando’s), moet je een account aanmaken op Docker Hub. Zie Docker Hub als een centrale plek waar developers hun Docker-images kunnen opslaan en delen.

Vertrouwd raken met veelgebruikte Docker-commando’s

Zodra Docker op je machine (of server) staat, is de volgende stap om bekend te raken met enkele Docker-commando’s. Hier is de lijst met commando’s waar je in de officiële Docker-documentatie naar kunt verwijzen. 

Om je op weg te helpen, hebben we de tien meest gebruikte Docker-commando’s uitgelicht die je zeker gaat tegenkomen.

1. docker run: Dit commando gebruik je om een container vanuit een image te draaien. De -p vlag mappt een poort op de hostmachine naar een poort in de container. Bijvoorbeeld, het volgende commando draait een container vanuit de "nginx"-image en mappt poort 80 op de hostmachine naar poort 80 in de container.
• docker run -p 80:80 nginx
2. docker ps: Dit commando toont alle draaiende containers. Handig wanneer we meerdere geïsoleerde containers op dezelfde machine hebben draaien.
• docker ps
3. docker stop: Dit commando stopt een draaiende container.
• docker stop <container_id>
4. docker rmDit commando verwijdert een gestopte container. 
• docker rm <container_id>
5. docker images: Dit commando toont alle images op de hostmachine. Handig om de lokale images te bekijken voordat we ze draaien om een container te maken.
• docker images
6. docker rmi: Dit commando verwijdert een image.
• docker rmi <image_id>
7. docker build: Dit commando bouwt een image vanuit een Dockerfile. De -t vlag specificeert de naam van de image en de . aan het einde geeft de buildcontext aan, namelijk de huidige map.
• docker build -t my_image .
8. docker exec: Dit commando draait een commando binnen een draaiende container.
• docker exec -it <container_id> /bin/bash
9. docker pull: Dit commando haalt een image op uit een registry, zoals Docker Hub. 
• docker pull <image_name>
10. docker push: Dit commando pusht een image naar een registry.
• docker push <image_name>

Nu we hebben geleerd hoe we Docker installeren en de veelgebruikte commando’s, is ons volgende doel een machinelearning-applicatie te dockerizen.

Wil je een Docker-certificering halen? Bekijk onze gids voor het behalen van een Docker-certificering!

Een eenvoudige machinelearning-applicatie dockerizen

Het dockerizen van een machinelearning-applicatie is makkelijker dan je denkt als je een simpel driestappenplan volgt.

Afbeelding door de auteur.

Laten we een script op beginnersniveau nemen om het simpel te houden, want ons doel is te laten zien hoe je een script dockerizet. In het voorbeeld bouwen we een eenvoudig logistic regression-model op de iris-dataset.

# Load the libraries

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import accuracy_score


# Load the iris dataset

iris = load_iris()

X = iris.data

y = iris.target


# Split the data

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)


# Train a logistic regression model

clf = LogisticRegression()

clf.fit(X_train, y_train)


# Make predictions

y_pred = clf.predict(X_test)


# Print the accuracy of the model

accuracy_score = accuracy_score(y_test, y_pred)

print(f'Accuracy: {accuracy_score}')

1. De omgeving definiëren

Je moet precies weten hoe de huidige omgeving eruitziet om die elders te kunnen reproduceren. De makkelijkste (en meest gebruikelijke) manier is een requirements.txt-bestand maken met alle libraries die je project gebruikt, inclusief hun versies.

Zo ziet de inhoud van het bestand eruit:

scikit-learn==1.2.0

Opmerking: Een complexere machinelearning-applicatie gebruikt meer libraries zoals NumPy, pandas, matplotlib en andere. Daarom is een requirements.txt-bestand maken logischer dan simpelweg de library installeren (meer hierover bij de best practices verderop).

2. Schrijf een Dockerfile

Onze volgende stap is een bestand met de naam Dockerfile maken dat de omgeving kan opzetten en onze applicatie daarin uitvoert. Simpel gezegd is het onze gebruiksaanwijzing voor Docker, waarin staat hoe de omgeving eruit moet zien, wat erin zit en welke stappen uitgevoerd worden.

FROM python:3.9

WORKDIR /src

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python","iris_classification.py"]

Deze Dockerfile gebruikt de officiële Python-image als basisimage, stelt de werkmap in, kopieert het bestand requirements.txt en installeert de dependencies, kopieert de applicatiecode en draait het commando python iris_classification.py om de applicatie te starten.

3. De image bouwen

De laatste stap om een reproduceerbare omgeving te maken is het creëren van een image (ook wel template), die je kunt draaien om elk gewenst aantal containers met dezelfde configuraties te maken.

Je bouwt de image met het commando docker build -t <image-name> . in dezelfde map waar de Dockerfile staat.

Nu je de eenvoudige machinelearning-applicatie hebt gedockerized, kun je met docker run containers maken en ze vervolgens stoppen wanneer nodig. We hebben de veelgebruikte commando’s hierboven al behandeld.

Laten we nu van basiskennis naar industriestandaarden gaan.

Best practices voor het gebruik van Docker

Hoewel basiskennis genoeg is om te starten, is het in de praktijk belangrijk om best practices te volgen. 

Het aantal lagen laag houden

Elke instructie in de Dockerfile resulteert in een nieuwe laag. Te veel lagen maken de image groot en traag om te versturen. 

Bekijk de onderstaande code:

# Use the official Python image as the build image

FROM python:3.9


# Install the dependencies

RUN pip install pandas

RUN pip install matplotlib

RUN pip install seaborn


# Copy neccesary files

COPY my_script.py .

COPY data/ .


# Run the script

CMD ["python","my_script.py"]

Welk probleem zie je hier? Het gebruik van meerdere run- en copy-commando’s was onnodig. Zo kun je het oplossen:

# Use the official Python image as the build image

FROM python:3.9


# Install the dependencies using requirements.txt

COPY my_script.py requirements.txt data/ .

RUN pip install --no-cache-dir -r requirements.txt


# Run the script

CMD ["python","my_script.py"]

Hoewel het in een klein bestand duidelijk is, zul je versteld staan hoe vaak we grotere Dockerfiles schrijven dan nodig. Het groeperen van commando’s die vergelijkbare functies uitvoeren of hetzelfde bestand wijzigen, is een makkelijke manier om het aantal lagen te verminderen.

Officiële images gebruiken

Officiële images worden onderhouden en ondersteund door de uitgever van de image. Deze images gelden over het algemeen als stabieler en veiliger dan andere. 

Soms gebruiken we in de haast onzorgvuldig een niet-officiële image. Gebruik waar mogelijk officiële images als basis voor je eigen images.

Multi-stage builds voor performance-optimalisatie

Een multi-stage build in Docker laat je meerdere FROM-instructies in één Dockerfile gebruiken. 

We kunnen een grotere image gebruiken als buildimage om de applicatie te bouwen en daarna de benodigde bestanden kopiëren naar een kleinere runtime-image. Door overbodige bestanden niet mee te nemen, verkleinen we de uiteindelijke image, wat niet alleen de performance optimaliseert maar de applicatie ook veiliger maakt. 

Bekijk een voorbeeld om dit beter te begrijpen, want dit wordt in de industrie vaak gebruikt:

# Use the official Python image as the build image

FROM python:3.9 AS build

# Set the working directory

WORKDIR /app

# Copy the requirements.txt file

COPY requirements.txt ./

# Install the dependencies

RUN pip install --no-cache-dir -r requirements.txt

# Copy the application files

COPY . .

# Train the model

RUN python train.py

# Use the official Alpine Linux image as the runtime image

FROM alpine:3

# Set the working directory

WORKDIR /app

# Copy the model files from the build image

COPY --from=build /app/models /app/models

# Copy the requirements.txt file

COPY --from=build /app/requirements.txt /app

# Install the dependencies

RUN pip install --no-cache-dir -r requirements.txt

# Run the application

CMD ["python","predict.py"]

Als we dit voorbeeld ontleden: we gebruiken eerst de officiële Python-image als buildimage en installeren in die fase alle dependencies. 

Na het draaien van het train.py-bestand kopiëren we de gegenereerde modelfiles en het bestand requirements.txt naar een kleinere Alpine Linux-image voor runtime, die we gebruiken om de applicatie te draaien. Door een multi-stage build te gebruiken en geen builddependencies en de Python-interpreter in de finale image op te nemen, hebben we de uiteindelijke image een stuk kleiner gemaakt.

Volumes gebruiken om data te behouden

Data binnen een container is niet meer beschikbaar zodra die is gestopt en verwijderd, maar soms heb je de resultaten van experimenten later nog nodig. Of je wilt data delen tussen meerdere containers.

Met het volume-commando zorg je dat de data buiten de container bewaard blijft. Zo zou je dat kunnen doen:

# Use the official Python image as the base image

FROM python:3.9

# Set the working directory

WORKDIR /app

# Copy the requirements.txt file

COPY requirements.txt ./

# Install the dependencies

RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the application files

COPY . .

# Create a directory for storing data

RUN mkdir /app/data



# Define a volume for the data directory

VOLUME /app/data

# Run the application

CMD ["python","main.py"]

Docker-images organiseren en versies beheren

Als je met meerdere Docker-images werkt, wordt het al snel onoverzichtelijk en ontstaat de behoefte om ze te organiseren. Hoewel de werkwijze per organisatie verschilt, kunnen we een paar algemene praktijken schetsen voor het organiseren van Docker-images:

1. Hanteer een consistente naamgevingsconventie voor elke image. Bijvoorbeeld het format <registry>/<organization>/<image>:<version>. Dit helpt om images en hun versies in de registry te herkennen.
2. Versiebeheer voor images is essentieel, zodat je indien nodig kunt terugdraaien naar een vorige versie. Je zag al hoe de versie een rol speelt in de naamgeving; die kun je uitbreiden als major>.<minor>.<patch>.
3. Images taggen met betekenisvolle labels zoals latest, staging, production helpt ook bij het organiseren en beheren. Zo herken je snel welke images bedoeld zijn voor verschillende omgevingen en fasen in de deploymentpipeline.

Het is aan te raden om dit binnen je organisatie af te stemmen; het hele team volgt dan dezelfde conventie.

Conclusie

Dit artikel besprak het belang voor data scientists om code en applicaties reproduceerbaar te maken met tools zoals Docker. We begonnen met het belang van Docker voor data scientists, gingen door de installatie-instructies en bekeken enkele veelgebruikte Docker-commando’s. Vervolgens lieten we zien hoe je machinelearning-applicaties kunt dockerizen met voorbeeldcode en welke best practices uit de industrie je daarbij volgt.

Voor verdere verdieping kun je onze cursus Introduction to Docker volgen, die veel van de essentials behandelt. Overweeg ook een Docker-certificering als je in het vakgebied werkt. 

De meeste data scientists focussen op kernvaardigheden zoals statistiek, wiskunde, machine learning, deep learning en coderen, maar vergeten de software-engineering-best practices te leren die in de industrie verwacht worden.

Wil je je kennis van core data science verstevigen? Bekijk dan de Data Scientist with Python-track met begeleide projecten. Moet je je software-engineering-skills opfrissen? Bekijk dan de cursus software engineering for data scientists with Python, met essentiële concepten zoals modulariteit, documentatie en geautomatiseerd testen.