Cursus
Concepten van Large Language Models (LLMs)
2 uur
113.4K
Hoewel de meeste mensen Google met zoekmachines associeren, heeft het bedrijf ook diepe wortels in de data science-industrie. Het levert consequent state-of-the-art producten en oplossingen om het maximale uit data te halen. Een van die producten, Vertex AI, werd in 2021 gelanceerd om het machinelearningproces op ondernemingsschaal te vereenvoudigen.
In deze tutorial leer je hoe je aan de slag gaat met Google’s Vertex AI-platform en hoe je het gebruikt voor een breed scala aan taken binnen de ML-levenscyclus. We eindigen met een gedeployed model dat we kunnen gebruiken om verzoeken te versturen en voorspellingen te genereren voor een classificatietaak.
Wat is Vertex AI?
Een typische machinelearning-levenscyclus bestaat uit veel fasen:
- Datavoorbereiding, -inname, -verkenning
- Feature engineering, selectie
- Modeltraining en -afstemming
- Deployen en modellering monitoren
Al deze fasen en subfasen vereisen een andere set tools en een divers team van experts om ze te coördineren.
Vertex AI van Google Cloud stroomlijnt en verenigt dit hele proces in één platform.
Hoewel grootschalige ML-toepassingen ervaren specialisten vereisen, stelt Vertex AI gebruikers van elk vaardigheidsniveau in staat:
- AutoML voor beginners: Vereist geen programmeerervaring. Voer je data in en met een paar klikken genereert AutoML een hoogwaardig model voor je. Al het zware werk van datavoorbereiding en modelbouw, inclusief algoritmeselectie en hyperparametertuning, gebeurt onder de motorkap.
- Aangepaste modeltraining voor experts: Je ervaring is de grens. Voor ervaren data scientists en ML-engineers biedt Vertex AI de flexibiliteit om modellen te trainen met hun favoriete frameworks, zoals PyTorch, TensorFlow of XGBoost.
- Deployen voor iedereen: Zodra je een model hebt getraind met AutoML of als maatwerk, maakt Vertex AI het deployen ervan een fluitje van een cent. Je kunt modellen publiceren als real-time API’s om te integreren in je producten of batchvoorspellingen gebruiken voor grootschalige taken.
We noemen hier lang niet alles, want met de meeste onderdelen ga je in deze tutorial zelf aan de slag.
Wat zijn Google Cloud-services?
Voordat we het platform gaan verkennen, moeten we de overkoepelende laag noemen: Google Cloud-services. Google Cloud-services omvatten een breed scala aan cloudoplossingen voor opslag, netwerken, databases, analytics en machine learning.
Deze services werken samen met Vertex AI om je machinelearning-workflow te verenigen. Hier volgt een overzicht van services die vaak met Vertex AI worden gebruikt:
Dataopslag en -beheer
- Cloud Storage: Dient als centrale repository voor je ruwe data, toegankelijk voor Vertex AI voor training en analyse.
- BigQuery: Een krachtig datawarehouse voor het opslaan en bevragen van grote datasets, waarmee Vertex AI BigQuery ML kan gebruiken voor training binnen de suite.
Rekenbronnen
- Compute Engine: Biedt virtuele machines met diverse configuraties voor je behoeften aan aangepaste modeltraining. Vertex AI kan met deze machines koppelen voor rekenintensieve trainingstaken.
- Vertex AI Pipelines: Coördineert complexe ML-workflows over verschillende rekenbronnen voor efficiëntie.
Google Cloud-services zijn altijd beschikbaar via je Google-account als je cloud.google.com bezoekt. Als je ze nog nooit hebt gebruikt, klik dan op “Get started for free” om je gratis proefperiode te starten.
Anders kun je direct naar console.cloud.google.com gaan zodat we kunnen beginnen.
Je Google Cloud Console instellen voor Vertex AI
Disclaimer: Als je de tutorial stap voor stap wilt volgen, houd er dan rekening mee dat je $25–30 aan Vertex AI kunt uitgeven. We gebruiken de goedkoopste configuraties.
Wanneer je je Google Cloud Console bezoekt, kom je waarschijnlijk op de volgende welkomstpagina terecht:
Hier staat de naam van je werkruimte; de mijne is ibexprogramming.com.
Het eerste wat we doen, is een project aanmaken. Google Cloud-projecten zijn organisatorische eenheden op hoog niveau voor het beheren van resources voor een specifieke taak. Hier is een GIF met hoe je er een aanmaakt:
Zodra het project is aangemaakt, selecteer je het zodat de bovenbalk van de pagina dit weergeeft:
Nu moet je een factureringsaccount aanmaken, want Vertex AI vereist factuurgegevens om services in te schakelen. Geen zorgen — je wordt niet in rekening gebracht totdat je betaalde resources gebruikt. Ga dus naar https://console.cloud.google.com/billing:
Als je nog geen account hebt zoals ik, klik dan op “Create account” en volg de instructies. We koppelen dit factureringsaccount in de volgende sectie aan het onze.
Ga daarna terug naar https://console.cloud.google.com/ en klik onderaan de pagina op de knop “View all products”:
Op de volgende pagina staan alle services die Google Cloud voor je project aanbiedt. Zoek naar “Vertex AI” (Ctrl + F) en pin het aan je menu voor snelle toegang. Klik daarna op de service zelf:
Dit brengt je naar je Vertex AI-dashboard. Er kan een venster verschijnen met de vraag om de Vertex AI API in te schakelen — kies “Enable.” Als het venster niet verschijnt, kun je op de knop “Enable all API permissions” klikken om hetzelfde te doen.
We zijn nu klaar om een dataset te uploaden naar Vertex AI.
Een dataset uploaden in Vertex AI
Er zijn verschillende manieren om een dataset toe te voegen aan Vertex AI. In deze sectie gebruiken we voor de eenvoud een lokaal CSV-bestand.
Download een voorbeeld-dataset
Voor dit artikel gebruiken we de Dry Bean-dataset van de UCI Machine Learning Repository. Deze bevat 13k voorbeelden van bonen en hun 15 numerieke metingen.
De taak is om ze in te delen in zeven typen bonen: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz en Sira.
Sla na het downloaden het Excel-bestand in de gedownloade ZIP op in je lokale map:
from pathlib import Path
cwd = Path.cwd()
data_path = cwd / "data" / "Dry_Bean_Dataset.xlsx"
Vervolgens kunnen we dit bestand met pandas inlezen en opslaan als CSV:
import pandas as pd
beans = pd.read_excel(data_path)
beans.shape
(13611, 17)Let op: de functie read_excel vereist dat je de openpyxl-bibliotheek met PIP installeert.
Mooi, we hebben de dataset als DataFrame. Laten we hem opslaan als CSV:
beans.to_csv(cwd / "data" / "dry_bean.csv", index=False)Maak een Cloud Storage-bucket
Zoals eerder genoemd, hebben we een Google Storage-bucket nodig om onze ruwe data op te slaan. Volg de onderstaande GIF om naar het dashboard van het product te navigeren:
De GIF laat zien dat we om opslagservices te gebruiken een factureringsaccount moeten koppelen; dat doen we met het account dat we eerder hebben gemaakt. Vervolgens kun je een bucket maken met een wereldwijd unieke naam:
Zodra je een unieke naam hebt gevonden, klik je op “Continue” totdat de bucket is aangemaakt — je kunt voor alle velden de standaardopties kiezen.
We zijn nu klaar om het CSV-bestand te importeren dat we in de vorige sectie hebben opgeslagen.
Een lokale CSV in Vertex AI inladen
Laten we nu teruggaan naar ons Vertex AI-dashboard en het tabblad Datasets bekijken:
Je vindt het leeg, dus klik op de knop “+Create”:
Geef de dataset een unieke naam en kies de tabulaire optie:
Daarna toont het platform je bronopties. Kies om een lokaal CSV-bestand te uploaden en selecteer voor het Cloud Storage-pad de bucket die je zojuist hebt gemaakt:
Zodra de dataset succesvol is geüpload, zie je het tabblad “Analyze”, dat basis-metadata over het CSV-bestand toont. Je ziet ook een knop “TRAIN NEW MODEL”, waarmee je een AutoML-trainingsjob start.
Die knop gebruiken we echter niet, want die is bedoeld voor complete ML-beginners. In plaats daarvan gebruiken we Vertex AI Workbench om een JupyterLab-codeomgeving en rekenbronnen te configureren om zowel AutoML als aangepaste libraries te draaien.
JupyterLab en rekenbronnen configureren in Vertex AI Workbench
Omdat Vertex AI een uniform platform is, biedt het ook ontwikkelomgevingen, zogenaamde workbenches. Om een workbench te maken, ga je naar het bijbehorende tabblad en volg je de instructies in de GIF hieronder:
Elke workbench wordt geleverd met JupyterLab 3 vooraf geïnstalleerd. Je hoeft dus alleen de hardware-opties te configureren op basis van je budget en behoeften. Omdat we een vrij kleine dataset hebben, koos ik voor illustratie het zwakste exemplaar, dat slechts ~$0,12 per uur kost (ik raad een machine met meer CPU-cores aan om de berekeningen te versnellen).
Ik heb ook de idle shutdown-tijd ingesteld op 10 minuten, zodat de omgeving automatisch stopt als ik vergeet hem uit te zetten.
Het initialiseren van de workbench duurt even. Zodra dat is voltooid, verschijnt de knop “OPEN JUPYTERLAB” en kunnen we erop klikken:
We worden doorgestuurd naar de vertrouwde JupyterLab-interface. Maak daar een nieuw Python 3-notebook en hernoem het zoals je wilt. Installeer/upgrade in de eerste cel de Google Cloud-services SDK google-cloud-aiplatform:
!pip3 install --upgrade --quiet google-cloud-aiplatform
Vervolgens kun je de projecten onder je account tonen met gcloud config list:
!gcloud config list
[compute]
region = us-central1
[core]
account = # HIDDEN #
disable_usage_reporting = True
project = vertexai-tutorial-423010
[dataproc]
region = us-central1
Your active configuration is: [default]
gcloud en gsutil zijn beide terminalhulpprogramma’s die in alle workbenches beschikbaar zijn. Ze stellen je in staat om je Google Cloud-services efficiënt te beheren.
Sla op basis van de uitvoer de volgende informatie op als Python-variabelen:
PROJECT_ID = 'vertexai-tutorial-423010'
BUCKET_URI = 'gs://vetex-tutorial-bucket-bex'
REGION = 'us-central1'
Vergeet niet om BUCKET_URI te wijzigen naar de naam van je eigen bucket. Importeer vervolgens de aiplatform-submodule en initialiseer die:
from google.cloud import aiplatform as ai
ai.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)
aiplatform fungeert als SDK om te communiceren met Vertex AI-functies.
Als je klaar bent met de tutorial of pauzeert, vergeet dan niet de instance te STOPPEN om ongewenste kosten te voorkomen.
AutoML-modellen trainen en deployen in Vertex AI
Laten we nu een model trainen met AutoML, dat, zoals eerder genoemd, al het zware werk voor ons doet en het beste model teruggeeft dat het voor de gegeven dataset kan trainen. Dit betekent dat je, om optimaal te profiteren van AutoML, moet zorgen dat de dataset die je aanlevert zo hoogwaardig mogelijk is. Het loont dus om vooraf tijd te besteden aan feature engineering en eventuele preprocessing-stappen.
AutoML voert intern preprocessing op de dataset uit, maar kan niet alle problemen met je dataset oplossen.
In deze sectie trainen we echter alleen een baseline AutoML-model zonder preprocessing of feature engineering, voor de eenvoud.
Data laden vanuit een Google Storage-bucket
Het eerste wat we willen doen, is de CSV-dataset uit onze bucket laden en wat tijd besteden aan het verkennen ervan. Onthoud, EDA is een belangrijke stap, en je kunt er meer over leren in onze Exploratory Data Analysis in Python-cursus!
import pandas as pd
# Path to your CSV file in GCS bucket
gcs_path = "gs://vertex-tutorial-bucket-bex/dry_bean.csv"
beans = pd.read_csv(gcs_path)
beans.head()
Het goede nieuws is dat pandas bestanden kan downloaden van GCS-paden. De enige kanttekening is dat de bovenstaande code alleen werkt in Vertex AI-workbenches, omdat die al geauthenticeerd zijn met je Google Cloud-referenties.
Data verkennen met pandas in Vertex AI
We voeren geen diepgaande analyse van de dataset uit, omdat dat ons van het hoofddoel van het artikel zou afleiden. We beperken ons dus tot het afdrukken van een paar samenvattende statistieken en grafieken:
beans.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 13611 entries, 0 to 13610
Data columns (total 17 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Area 13611 non-null int64
1 Perimeter 13611 non-null float64
2 MajorAxisLength 13611 non-null float64
3 MinorAxisLength 13611 non-null float64
4 AspectRation 13611 non-null float64
5 Eccentricity 13611 non-null float64
6 ConvexArea 13611 non-null int64
7 EquivDiameter 13611 non-null float64
8 Extent 13611 non-null float64
9 Solidity 13611 non-null float64
10 roundness 13611 non-null float64
11 Compactness 13611 non-null float64
12 ShapeFactor1 13611 non-null float64
13 ShapeFactor2 13611 non-null float64
14 ShapeFactor3 13611 non-null float64
15 ShapeFactor4 13611 non-null float64
16 Class 13611 non-null object
dtypes: float64(14), int64(2), object(1)
memory usage: 1.8+ MB
We zien dus 15 numerieke features en één doelkolom — Class. Er zijn slechts ~13k records en geen missende waarden. Dat maakt het trainen een stuk eenvoudiger.
Laten we de featurenamen opslaan in een aparte lijst, mogelijk hebben we die later nodig:
feature_names = beans.columns.tolist()
Laten we nu een pairplot maken van een paar belangrijke features:
import seaborn as sns
sns.pairplot(
beans,
vars=["Area", "MajorAxisLength", "MinorAxisLength", "Eccentricity", "roundness"],
hue="Class",
);
We zien een paar interessante trends — vooral lijkt het erop dat Bombay (groen) duidelijk is gescheiden van de anderen qua fysieke metingen.
Laten we ook een correlatiematrix plotten:
import matplotlib.pyplot as plt
correlation = beans.corr(numeric_only=True)
# Create a square heatmap with center at 0
sns.heatmap(correlation, center=0, square=True, cmap="coolwarm", vmin=-1, vmax=1)
plt.show()
We hebben een paar features die bijna perfect correleren, wat logisch is omdat het om fysieke metingen gaat. Er zijn echter ook featureparen die weinig tot geen correlatie vertonen.
Op dit punt laat ik het aan jou over om de verkenning voort te zetten en te proberen vragen over de dataset te formuleren en te beantwoorden.
Een AutoML-trainingsjob uitvoeren
Om een AutoML-trainingsjob te starten, hebben we eerst een datasetobject nodig dat ermee compatibel is:
ds = ai.TabularDataset.create(
display_name="dry_bean_dataset", gcs_source=gcs_path
)
TabularDataset created.
type(ds)google.cloud.aiplatform.datasets.tabular_dataset.TabularDataset
ds.resource_name
'projects/10783853768/locations/us-central1/datasets/4978116960081412096'
We gebruiken de methode TabularDataset.create om hem als ds te initialiseren. Vertex AI kent er een eigen naam aan toe, die toegankelijk is via het attribuut resource_name.
Nu initialiseren we de job met de klasse ai.AutoMLTabularTrainingJob. Deze vereist twee argumenten:
- Een weergavenaam voor de job
- Het doel van de taak — in dit geval classificatie.
job = ai.AutoMLTabularTrainingJob(
display_name="dry-bean-classification",
optimization_prediction_type="classification",
)
Vervolgens draaien we de run-methode van de job:
model = job.run(
dataset=ds,
target_column="Class",
training_fraction_split=0.8,
validation_fraction_split=0.1,
test_fraction_split=0.1,
model_display_name="baseline-classification-model",
disable_early_stopping=False,
)
De parameters van de methode spreken grotendeels voor zich. Het uitvoeren van de code duurt even (afhankelijk van je rekenkracht).
Als je naar het tabblad “MODEL DEVELOPMENT > TRAINING” van je dashboard gaat en op de jobnaam klikt, zie je de voortgang van de training live. De onderstaande afbeelding laat zien dat de training zich in de preprocessing-fase bevindt:
Naar de resultaten kijken
Zodra de training is voltooid, ga je opnieuw naar het trainingstabblad en klik je op de modelnaam. Dit keer worden er prestatiemetrics naast het model weergegeven:
Zoals je ziet hebben we, zelfs voor een basismodel, zeer goede metrics, allemaal boven de 0,90.
Een AutoML-model deployen en voorspellingen genereren
We kunnen dit model nu met één regel code deployen:
endpoint = model.deploy(machine_type="n1-standard-4")
De methode deploy vereist maar één argument: het type machine voor inference. Ik zal de bovenstaande regel niet daadwerkelijk uitvoeren, omdat deployen extra kosten met zich meebrengt zolang het model online is.
Als je hem wel uitvoert, geeft de methode deploy een Endpoint-object terug waarnaar we verzoeken kunnen sturen:
prediction = endpoint.predict(
[
{
"Area": "30099",
"Perimeter": "638.8209999999999",
"MajorAxisLength": "237.14191130827916",
"MinorAxisLength": "162.3034300714102",
"AspectRation": "1.4611022774068396",
"Eccentricity": "0.7290928631259719",
"ConvexArea": "30477",
"EquivDiameter": "195.76321681302556",
"Extent": "0.8036043251902283",
"Solidity": "0.9875972044492568",
"roundness": "0.9268374259664279",
"Compactness": "0.8255108332939839",
"ShapeFactor1": "0.007878730566074592",
"ShapeFactor2": "0.002256976927384019",
"ShapeFactor3": "0.6814681358857279",
"ShapeFactor4": "0.9956946453228307",
}
]
)
print(prediction)
Het heeft een methode predict die een lijst met samples accepteert om te voorspellen. De samples moeten in JSON-formaat worden aangeleverd.
Je kunt ook het dashboard gebruiken om modellen te deployen. Als je naar het tabblad “MODEL REGISTRY” gaat, zie je daar het model staan. Klik op de naam en kies het tabblad “DEPLOY & TEST”:
Door op de knop ‘DEPLOY TO ENDPOINT’ te klikken ga je naar een aparte pagina waar je de machine kunt configureren om je model te deployen. Maar voordat je dat doet, kun je het hieronder testen:
Aangepaste modellen trainen en deployen in Vertex AI
Aangepaste modellen deployen in Vertex AI is uitdagender dan AutoML-modellen en kost ook meer, omdat er Docker-containers bij komen kijken naast je Workbench- en deploymentkosten. Als je er klaar voor bent, gaan we aan de slag!
Overzicht op hoofdlijnen van aangepaste training in Vertex AI
Aangepaste training begint met een aangepaste trainingsscript. In dit script kun je alles doen, zolang het:
- Data uit een GCS-bucket laadt
- Een model traint met een ML-framework (TF, PyTorch, Scikit-learn, XGBoost)
- Optioneel de hyperparameters van het model afstemt
- Het model opslaat in de GCS-bucket om het getrainde of afgestemde model vast te leggen.
Vervolgens moet dit trainingsscript in een Docker-container worden omgezet en naar Google Container Registry worden gepusht. Van daaruit kunnen we de Vertex AI Python SDK of het dashboard gebruiken om het aangepaste model te trainen.
Een mappenstructuur maken voor de trainingscode
Laten we eerst de mappenstructuur maken zoals aanbevolen in deze codelab van Google. Schakel in je workbench over naar de terminal door een nieuwe launcher te starten:
Maak vervolgens een nieuwe map “dry-beans” en ga erin:
$ mkdir dry-beans
$ cd dry-beans/
Maak binnen dry-beans nog een map trainer en daarin het Python-bestand train.py:
$ mkdir trainer
$ touch trainer/train.py
Een Dockerfile maken
Maak vervolgens een nieuwe Dockerfile aan:
$ touch Dockerfile
Open het bestand en plak de volgende inhoud:
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-6
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Install XGBoost
RUN pip install xgboost==1.6.2
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
Deze Dockerfile gebruikt de officiële deep learning-image van Google Container Registry met TensorFlow geïnstalleerd. Het bestand kopieert onze map trainer en installeert vervolgens XGBoost. Tot slot wordt ons Python-script uitgevoerd.
Het trainingsscript schrijven
Het script zelf moet de Dry Beans-dataset uit onze GCP-bucket laden, er een XGBoost-classifier op trainen en het model terug naar de bucket opslaan. Ik heb een eenvoudig script geschreven dat deze taken uitvoert in deze GitHub-gist (ik deel het hier niet om ruimte te besparen).
Kopieer/plak de code uit de gist naar train.py. Installeer vervolgens in de terminal XGBoost, omdat het niet vooraf is geïnstalleerd in je gekozen Workbench, en voer het script uit:
$ pip install xgboost==1.6.2
$ python trainer/train.py
Een Docker-image bouwen
Als het script zonder fouten draait, ga dan verder door deze twee variabelen in de terminal in te voeren:
$ PROJECT_ID='vertexai-tutorial-423010' # Replace with your PROJECT_ID from earlier
$ IMAGE_URI="gcr.io/$PROJECT_ID/dry-beans:v1" # This stays the same
Deze variabelen gebruiken we bij het bouwen van de container, dus doen we:
$ docker build ./ -t $IMAGE_URI
Het bouwen duurt even. Voer na afloop de container uit om te controleren of alles soepel draait:
$ docker run $IMAGE_URI
Model trained successfully!
Model uploaded successfully!
Als je bovenstaande succesberichten krijgt, is de container klaar om te pushen:
$ docker push $IMAGE_URIEen aangepaste trainingsjob maken
Op dit punt is het grootste werk gedaan. We kunnen nu overschakelen naar het dashboard en een aangepaste trainingsjob maken met de container die we zojuist hebben gepusht. Ga dus naar het tabblad “MODEL REGISTRY” en klik op “CREATE”:
Kies voor de trainingsmethode de opties “No managed dataset” en “Custom training”. Geef in het volgende paneel (Model details) het model een naam — dry-beans-classifier.
In het paneel voor de trainingscontainer:
Selecteer de container die we voor de custom image hebben gepusht en de bucket cloud-ai-platform voor de modeloutput. Klik vervolgens door tot je bij het paneel "Compute and pricing" komt:
Kies een standaard n1-machine met 4 CPU’s en klik tot slot op "START TRAINING". Schakel daarna over naar het tabblad "TRAINING" van je dashboard.
Op dit punt zie je een van de twee dingen:
- De status training failed
- De status training in progress
Ik heb het eerste, dus laten we onderzoeken waarom door op de modelnaam te klikken:
De fout meldt dat ik het toegestane aantal aangepaste trainings-CPU’s heb overschreden. Ik heb het probleem verder onderzocht en wat ik vond, was behoorlijk teleurstellend.
Normaal gesproken geeft GCP minstens 20 CPU-quota’s voor elke compute-regio, maar na het controleren van mijn profiel ontdekte ik dat mijn quota slechts 1 was. Dit betekende dat ik geen aangepaste trainingsjobs kon draaien, aangezien alle machines die Google aanbiedt minstens twee CPU’s hebben.
Ik heb geprobeerd mijn quota te verhogen met de antwoorden uit deze StackOverflow-thread, maar die werkten niet. De boodschap die ik kreeg, was dat nieuwe Vertex AI-gebruikers slechts één CPU-eenheid mochten gebruiken. Als ik mijn quota wilde verhogen, moest ik een supportticket indienen, wat, zo blijkt, niet gratis is (je hebt een betaald supportcontract nodig).
Dus als je net zo’n pech hebt als ik, probeer dan de antwoorden in de SO-thread. Ze werkten voor sommige mensen, maar als ze voor jou niet werken, is je enige optie om contact op te nemen met support.
Maar als je geluk hebt en je training voltooit, kun je het model deployen met dezelfde stappen als die ik voor AutoML-modellen heb beschreven.
Conclusie
Vertex AI is een enorm platform met veel functies. In deze tutorial hebben we slechts aan de oppervlakte gekrabd, maar we hebben de belangrijkste bouwstenen van het platform behandeld. Door het maken van storage-buckets, workbenches en trainingsjobs onder de knie te krijgen, ben je goed toegerust om de rest van het platform te verkennen.
Wil je meer leren over Google Cloud-services? Bekijk dan deze aanbevolen bronnen:
Onderwerpen
