Kennismaken met de Databricks-notebook: een complete gids

Databricks fungeert als een uniform analytics-platform en maakt de integratie mogelijk van data engineering, machine learning en business analytics. In de kern van dit ecosysteem staan Databricks-notebooks: interactieve werkruimtes voor data-exploratie, modelontwikkeling en productie-workflows.

In dit artikel laat ik je zien hoe je aan de slag gaat met Databricks-notebooks. Als je helemaal nieuw bent, begin dan met onze cursus Introduction to Databricks zodat je de ins en outs van Databricks begrijpt en ziet hoe het data-architectuur moderniseert. Onze cursus is grondig en behandelt veel onderwerpen, waaronder catalogusbeheer en data-ingestie—probeer ‘m gerust.

Wat zijn Databricks-notebooks?

Databricks-notebooks zijn interactieve, cloudgebaseerde werkruimtes waarmee je data-exploratie, engineering, machine learning en analytics kunt uitvoeren in een collaboratieve omgeving. Ze gebruiken een op cellen gebaseerd uitvoermodel, waarbij je code kunt schrijven en uitvoeren in afzonderlijke blokken of cellen.

Ondersteunde talen

Databricks-notebooks ondersteunen meerdere talen, zodat je niet alleen je favoriete taal kunt kiezen, maar ook binnen hetzelfde notebook tussen talen kunt wisselen. De talen zijn onder meer Python, SQL, Scala en R, waarvoor we allemaal introductiecursussen aanbieden.

Om meertalige interoperabiliteit te ondersteunen, biedt Databricks zogenoemde magic commands:

• %python: Voert een cel uit met Python.

• %sql: Voert SQL-queries uit.

• %scala: Verwerkt Scala-opdrachten.

• %r: Voert R-code uit.

Belangrijkste functies

Databricks-notebooks gaan verder dan traditionele codeeromgevingen dankzij de volgende kernmogelijkheden:

• Realtime samen schrijven: Meerdere gebruikers kunnen notebooks tegelijk bewerken, uitvoeren en erop reageren, wat naadloze samenwerking mogelijk maakt.
• Automatische versiebeheer: Ingebouwde versiegeschiedenis om wijzigingen te volgen, bewerkingen terug te draaien en code-integriteit te behouden.
• Interactieve uitvoering: Gebruikers kunnen afzonderlijke cellen of volledige workflows uitvoeren, waardoor debuggen en iteratieve ontwikkeling efficiënter worden.
• Ingebouwde visualisaties: Geïntegreerde ondersteuning voor het renderen van grafieken, tabellen en dashboards zonder externe libraries.
• Git-integratie: Native ondersteuning voor Git-repositories voor versiebeheer, code delen en CI/CD-workflows.

Aan de slag met Databricks-notebooks

Over functies lezen is één ding, maar het zelf zien is iets anders. De beste manier om Databricks te waarderen is door er zelf mee aan de slag te gaan. In deze sectie help ik je bij het maken, beheren en navigeren van notebooks in de Databricks-werkruimte. Dan zul je vanzelf zien hoe handig het is.

Notebooks maken en beheren

In de Databricks-werkruimte kun je nieuwe notebooks maken of bestaande notebooks beheren. Hieronder bekijken we deze methoden.

Hoe maak je een nieuw notebook in de Databricks-werkruimte

Zo maak je een nieuw notebook in Databricks:

• Navigeer naar je Databricks Workspace.

Databricks-werkruimte. Afbeelding door auteur.

• Klik op Workspace > Create > Notebook.

Databricks-notebook maken. Afbeelding door auteur.

• Geef een naam op, selecteer een standaardtaal en koppel een cluster.

Selecteer de naam en standaardtaal voor het Databricks-notebook. Afbeelding door auteur.

Bestaande notebooks importeren

Databricks laat je notebooks importeren uit meerdere bronnen, zoals GitHub en Git-repositories, externe URL’s of lokale bestanden die zijn geüpload als .dbc (Databricks-archief) of .ipynb (Jupyter)-bestanden.

Volg deze stappen om bestaande notebooks te importeren in de Databricks-werkruimte:

• Klik op Workspace > Import.

Bestaand notebook importeren naar Databricks-werkruimte. Afbeelding door auteur.

• Kies Source (URL, bestand of Git).

• Upload of geef de link naar het notebook op.

Hernoemen, organiseren en toegang beheren

Om een Databricks-notebook te hernoemen, klik je op de titel van het notebook en bewerk je de naam.

Je kunt notebooks ook naar mappen verplaatsen voor een betere structuur.

Databricks-notebooks naar een map verplaatsen. Afbeelding door auteur.

Voordat je je Databricks-notebook deelt, kun je toegang en permissies beheren om te bepalen wie het notebook mag bekijken, bewerken of beheren.

Basisnavigatie en UI-overzicht

Voordat we doorgaan met hands-on voorbeelden van Databricks-notebooks, neem ik je mee door de UI en navigatie van het platform.

Overzicht van de werkbalk, celacties en rechterzijbalk

De werkbalk van Databricks-notebooks biedt snel toegang tot de volgende acties:

• Run: Voer afzonderlijke cellen of het hele notebook uit. Elke cel heeft opties voor:

• De cel uitvoeren, bewerken, verwijderen of verplaatsen.

• Het type cel wijzigen, zoals code, markdown, SQL of Scala.

• Magic commands instellen zoals %python of %sql.

Een cel uitvoeren in een Databricks-notebook. Afbeelding door auteur.

• Status wissen: Reset variabelen en uitvoeringsstatus.

Variabelen en uitvoeringsstatus resetten in een Databricks-notebook. Afbeelding door auteur.

• Weergavemodus: Wissel tussen bewerken- en presentatiemodus.
• Reacties: Voeg gezamenlijke feedback toe aan specifieke cellen.

Reacties in een Databricks-notebook. Afbeelding door auteur.

• Revisies: Bekijk en herstel eerdere versies.

Versiegeschiedenis in een Databricks-notebook. Afbeelding door auteur.

Nieuwe UI-verbeteringen

Databricks heeft verschillende UI-verbeteringen geïntroduceerd voor een meer intuïtieve ervaring. Met deze verbeteringen bieden Databricks-notebooks een nog gestroomlijndere en krachtigere ontwikkelomgeving voor dataprofessionals. Ze omvatten het volgende:

• Moderne look-and-feel: Een strakkere, gebruiksvriendelijkere interface.
• Verbeterde Markdown-bewerking: Betere ondersteuning voor opmaak en het insluiten van visuals.
• Focusmodus: Minimaliseer afleiding door onnodige UI-elementen te verbergen.
• Interactief debuggen: Nieuwe debuggingtools voor stapsgewijze uitvoering en fouttracering.

Hands-on: code schrijven en uitvoeren

Databricks-notebooks bieden een interactieve codeeromgeving waarin je code kunt schrijven, uitvoeren en documenteren. In deze sectie behandel ik werken met codecellen, Markdown en het efficiënt uitvoeren van code.

Codecellen en Markdown

Databricks-notebooks ondersteunen meerdere talen, waaronder Python, SQL, Scala en R, binnen hetzelfde notebook.

Python-code schrijven in een Databricks-notebook

Gebruik de magic command %python om Python-code in een cel in het Databricks-notebook te schrijven.

%python
import pandas as pd
# Load sample data and display the first few rows
df = spark.read.format("csv").option("header", "true").load("/databricks-datasets/airlines/part-00000")
pd_df = df.limit(5).toPandas()  # Convert to Pandas DataFrame
display(pd_df)  # Works in DatabricksMogelijk gemaakt door

Voorbeeld van Python-code in een Databricks-notebook. Afbeelding door auteur.

SQL-code schrijven in een Databricks-notebook

Om SQL-code in een Databricks-notebook te schrijven, gebruik je de magic command %sql. Als SQL als standaardtaal van het notebook is ingesteld, kun je de cel uitvoeren zonder de magic command %sql op te nemen.

-- Querying a dataset in SQL
SELECT origin, dest, COUNT(*) AS flight_count 
FROM flights_table 
GROUP BY origin, dest 
ORDER BY flight_count DESC 
LIMIT 10;Mogelijk gemaakt door

SQL-code in een Databricks-notebook. Afbeelding door auteur.

Scala-code schrijven in een Databricks-notebook

Gebruik de magic command %scala om Scala-code in een cel in het Databricks-notebook te schrijven.

%scala
// Reading and displaying data in Scala
val data = spark.read.option("header", "true").csv("/databricks-datasets/airlines/part-00000")

// Display as a table in Databricks
display(data)Mogelijk gemaakt door

Scala-code in een Databricks-notebook. Afbeelding door auteur.

R-code schrijven in een Databricks-notebook

Je kunt ook R-code schrijven in een cel van het Databricks-notebook met de magic command %r.

%r
# Load a sample dataset in R
library(SparkR)
df <- read.df("/databricks-datasets/airlines/part-00000", source = "csv", header = "true")
head(df)Mogelijk gemaakt door

R-code in een Databricks-notebook. Afbeelding door auteur.

Markdown-cellen gebruiken voor documentatie

Markdown-cellen gebruik je om tekst, koppen, lijsten en andere documentatie toe te voegen. Het onderstaande voorbeeld laat zien hoe je een Markdown-cel schrijft en hoe de resultaten in Databricks-notebook worden weergegeven.

%md
# Data Exploration Notebook  
This notebook explores airline flight data, providing insights into flight frequency and destinations.  

## **Steps:**  
1. Load and display the dataset  
2. Query data using SQL  
3. Generate visualizationsMogelijk gemaakt door

Cellen uitvoeren

Databricks-notebooks maken flexibele uitvoering van code mogelijk via individuele of batchruns van cellen. 

Afzonderlijke cellen uitvoeren en alle cellen draaien

Om één cel uit te voeren, klik je op de knop Run (▶) in de cel of gebruik je de sneltoets:

• Shift + Enter: Voert de huidige cel uit en gaat naar de volgende.
• Ctrl + Enter: Voert de cel uit zonder naar de volgende te gaan.

Om alle cellen in het notebook uit te voeren:

• Klik op Run All in de werkbalk.
• Hiermee wordt het notebook sequentieel van boven naar beneden uitgevoerd.

Afzonderlijke cellen uitvoeren en alle cellen draaien in een Databricks-notebook. Afbeelding door auteur.

Uitvoer bekijken

Databricks-notebooks ondersteunen meerdere uitvoerformaten, waaronder tabellen, grafieken en logs. Zo toont de onderstaande Python-code de eerste 5 rijen van de ‘airlines’-dataset.

%python
import pandas as pd
# Load sample data and display the first few rows
df = spark.read.format("csv").option("header", "true").load("/databricks-datasets/airlines/part-00000")
# Displaying the first 5 rows of a DataFrame
display(df.limit(5))Mogelijk gemaakt door

Invoer bekijken in een Databricks-notebook. Afbeelding door auteur.

We kunnen ook de uitvoer van cellen visualiseren in Databricks-notebooks. De onderstaande Python-code selecteert bijvoorbeeld de 10 meest voorkomende luchtvaartmaatschappijen, zet de data om van PySpark naar Pandas en gebruikt vervolgens Matplotlib om een staafdiagram te maken.

%python
# Import necessary libraries
import matplotlib.pyplot as plt
import pandas as pd

# Load the dataset using PySpark
df = spark.read.option("header", "true").csv("/databricks-datasets/airlines/part-00000")

# Select the top 10 most frequent airlines (carrier column)
top_airlines = df.groupBy("UniqueCarrier").count().orderBy("count", ascending=False).limit(10)

# Convert PySpark DataFrame to Pandas DataFrame
pd_df = top_airlines.toPandas()

# Convert count column to integer (since it's a string in CSV)
pd_df["count"] = pd_df["count"].astype(int)

# Plot a bar chart
plt.figure(figsize=(10, 6))
plt.bar(pd_df["UniqueCarrier"], pd_df["count"], color="#ac4ce4")

# Add titles and labels
plt.xlabel("Airline Carrier", fontsize=12)
plt.ylabel("Flight Count", fontsize=12)
plt.title("Top 10 Most Frequent Airline Carriers", fontsize=14)
plt.xticks(rotation=45)  # Rotate x-axis labels for better readability

# Show the plot
plt.show()Mogelijk gemaakt door

Uitvoer visualiseren in een Databricks-notebook. Afbeelding door auteur.

Evenzo kun je meerdere uitvoeren tonen na het uitvoeren van één enkele cel in een Databricks-notebook. De uitvoer van de onderstaande code toont bijvoorbeeld de bovenste 5 rijen van de airlines-dataset en het aantal van de 10 meest voorkomende carriers.

%python
# Show the top 5 rows in an interactive table
display(df.limit(5))

# Show the top 10 most frequent airline carriers
top_carriers = df.groupBy("UniqueCarrier").count().orderBy("count", ascending=False).limit(10)
display(top_carriers)Mogelijk gemaakt door

Meerdere uitvoeren tonen na het uitvoeren van één cel in een Databricks-notebook. Afbeelding door auteur.

Geavanceerde functies van Databricks-notebooks

Databricks-notebooks bieden krachtige mogelijkheden voor automatisering, versiebeheer en integratie die productiviteit, samenwerking en operationele efficiëntie verbeteren. In deze sectie bespreek ik belangrijke geavanceerde functies en best practices om het maximale uit Databricks-notebooks te halen.

Automatisering en plannen

Databricks laat je de uitvoering van notebooks automatiseren door ze als jobs te plannen en invoer te parameteriseren voor dynamische uitvoering.

Notebooks plannen als jobs

Je kunt notebooks op ingestelde intervallen laten draaien, zodat ETL, rapportage en modeltraining geautomatiseerd verlopen. Volg deze stappen om een notebook-job te plannen:

• Open het notebook en klik op Run as Job of ga naar het tabblad Jobs.
• Klik op Create Job en selecteer het notebook.

Een Job Run aanmaken in een Databricks-notebook. Afbeelding door auteur.

• Configureer het schema en stel dagelijkse, uurlijkse en aangepaste cron-jobs in.

Planningen en triggers configureren in een Databricks-notebook. Afbeelding door auteur.

• Koppel een cluster en stel afhankelijkheden in indien nodig.
• Klik op Run Now om meteen uit te voeren, of laat het volgens schema draaien.

Job Runs uitvoeren in een Databricks-notebook. Afbeelding door auteur.

Parameters en widgets gebruiken voor dynamische uitvoering

Met Databricks-widgets kun je parameters dynamisch definiëren, zodat hetzelfde notebook met verschillende invoer kan draaien. Zo creëert de widget dbutils.widgets.text() hieronder een interactieve tekstinvoer met het label "Enter Parameter" en de standaardwaarde default_value. Vervolgens haalt hij de door de gebruiker ingevoerde waarde op en print die.

dbutils.widgets.text("input_param", "default_value", "Enter Parameter")
param_value = dbutils.widgets.get("input_param")
print(f"User Input: {param_value}")Mogelijk gemaakt door

Op vergelijkbare wijze genereert de onderstaande code een dropdownmenu met label dataset met de opties sales, marketing en finance, waarbij standaard sales is geselecteerd. Hij haalt de geselecteerde optie op en print de gekozen dataset.

dbutils.widgets.dropdown("dataset", "sales", ["sales", "marketing", "finance"])
selected_dataset = dbutils.widgets.get("dataset")
print(f"Processing {selected_dataset} dataset")Mogelijk gemaakt door

Versiebeheer en samenwerking

Databricks biedt ingebouwd versiebeheer en samenwerkingsfuncties, zodat je eenvoudig wijzigingen kunt bijhouden, eerdere versies kunt herstellen en in realtime met teams kunt werken.

Automatische versiegeschiedenis en Git-integratie

Elke wijziging in een Databricks-notebook wordt automatisch versiegemaakt. Voor de versiegeschiedenis kun je het volgende doen:

• Versiegeschiedenis bekijken: Klik op Revision History om wijzigingen te volgen.

Versiegeschiedenis bekijken in een Databricks-notebook. Afbeelding door auteur.

• Eerdere versies herstellen: Zo nodig terugrollen naar een eerdere staat.
• Git-integratie gebruiken: Synchroniseer notebooks met GitHub, Azure DevOps of Bitbucket voor versiebeheer.

Realtime samenwerkingsfuncties

Met Databricks-notebooks kunnen teams samen schrijven, reageren en inzichten delen via de volgende functies:

• Realtime samen bewerken: Meerdere gebruikers kunnen tegelijk een notebook bewerken.
• Inline reageren: Plaats reacties op specifieke codelijnen voor discussie.
• Delen en permissies: Ken rollen toe zoals Viewer, Editor en Owner om toegang te beheren.

Integratie met andere tools

Databricks-notebooks integreren met Delta Live Tables, MLflow, SQL Warehouses en CI/CD-pijplijnen om functionaliteit uit te breiden.

Databricks gebruiken met Delta Live Tables

Delta Live Tables (DLT) vereenvoudigen data pipeline-automatisering met declaratieve ETL. De volgende query maakt een Delta Live Table-pipeline in SQL.

-- Creating a live table called 'sales_cleaned' that stores cleaned data
CREATE LIVE TABLE sales_cleaned AS

    -- Selecting all columns where the 'order_status' is 'completed'
    SELECT * 
    FROM raw_sales
    WHERE order_status = 'completed'; Mogelijk gemaakt door

MLflow voor experimenttracking

MLflow, geïntegreerd met Databricks, maakt het mogelijk om machine learning-experimenten te tracken. De onderstaande code logt bijvoorbeeld de learning rate en nauwkeurigheid van een ML-model in MLflow als onderdeel van een gevolgd experiment. Na het loggen wordt de sessie beëindigd. Zo kun je hyperparameters en modelprestaties in de tijd volgen en verschillende runs vergelijken.

# Import the MLflow library for experiment tracking
import mlflow
mlflow.start_run()
    mlflow.log_param("learning_rate", 0.01)
    mlflow.log_metric("accuracy", 0.95)

mlflow.end_run()Mogelijk gemaakt door

Notebooks exporteren en CI/CD-integratie

Databricks-notebooks kunnen in verschillende indelingen worden geëxporteerd, waaronder:

• .html: Gedeelde, alleen-lezen rapporten.

• .ipynb: Converteren naar Jupyter-notebooks.

• .dbc: Databricks-archief voor draagbaarheid.

Je kunt bijvoorbeeld een notebook exporteren via de CLI met de volgende opdracht.

databricks workspace export /Users/my_notebook /local/path/my_notebook.ipynbMogelijk gemaakt door

Tips en trucs om Databricks-notebooks te beheersen

Databricks-notebooks bieden een reeks krachtige functies om workflows te stroomlijnen, de productiviteit te verhogen en de samenwerking te verbeteren. In deze sectie laat ik je magic commands, UI-verbeteringen, data-exploratietechnieken en codebeheerstrategieën zien die ik handig vind bij het navigeren op het Databricks-notebooksplatform.

Magic commands

Databricks biedt magic commands die taken vereenvoudigen, zoals scripts draaien, bestanden beheren en packages installeren.

%run

Om een ander notebook binnen het huidige notebook uit te voeren en workflows te modulariseren, kun je het commando %run gebruiken. Je kunt %run ook inzetten om grote projecten op te delen in herbruikbare notebooks. Het volgende commando draait bijvoorbeeld het notebook data_preprocessing zodat de variabelen, functies en outputs beschikbaar komen in het huidige notebook.

%run /Users/john.doe/notebooks/data_preprocessingMogelijk gemaakt door

%sh

Met het commando %sh kun je Linux-shellopdrachten direct in een notebook uitvoeren. In het onderstaande voorbeeld worden de inhoud van /dbfs/data/ in DBFS weergegeven.

%sh ls -lh /dbfs/data/Mogelijk gemaakt door

%fs

Evenzo kun je met het commando %fs interacteren met het Databricks File System (DBFS) voor bestandsbewerkingen. Het onderstaande commando toont bijvoorbeeld alle bestanden en mappen binnen /databricks-datasets/, dat publieke datasets van Databricks bevat.

%fs ls /databricks-datasets/Mogelijk gemaakt door

Evenzo kun je %fs cp gebruiken om bestanden te kopiëren, %fs rm om bestanden te verwijderen en %fs head om bestanden te previewen.

%pip

Met het commando %pip installeer je Python-packages binnen de notebook-omgeving. Het volgende commando installeert de package matplotlib binnen de huidige notebook-sessie.

%pip install pandas matplotlibMogelijk gemaakt door

Met het commando %pip freeze kun je geïnstalleerde packages weergeven en reproduceerbaarheid waarborgen.

UI-verbeteringen

Databricks heeft de volgende UI-verbeteringen geïntroduceerd die navigatie, debuggen en de algehele gebruikerservaring verbeteren:

• Nieuwe resultaatstabel: Betere visualisatie van queryresultaten met sorteerbare en filterbare tabellen.
• Verbeterde Markdown-editor: Verbeterde opmaak, codeblokken en ingesloten afbeeldingen.
• Interactieve debugger: Stapsgewijs debuggen voor het oplossen van complexe scripts.
• Inline Assistant (Databricks AI Assistant): Maakt code af, suggereert fixes en verhoogt de efficiëntie.

Ik raad altijd aan om de Focusmodus (View → Focus Mode) in te schakelen om afleiding te minimaliseren.

Data-exploratietechnieken

Databricks biedt ingebouwde tools om datasets te browsen, schema’s te begrijpen en data rechtstreeks in notebooks te profileren.

Om datasets in DBFS te verkennen, gebruik je %fs ls of display(dbutils.fs.ls()) om beschikbare datasets te inspecteren.

display(dbutils.fs.ls("/databricks-datasets/"))Mogelijk gemaakt door

Je kunt ook tabelschema’s rechtstreeks verkennen in de UI-zijbalk via de onderstaande stappen:

• Klik op Data in de werkruimte.
• Blader door databases en tabellen.
• Klik op een tabel om data en schema te bekijken.

Voor dataprofielen kun je samenvatten met display() of SQL-queries.

df.describe().show()Mogelijk gemaakt door

%sql
SELECT COUNT(*), AVG(salary), MAX(age) FROM employees;Mogelijk gemaakt door

Strategieën voor codebeheer

Gebruik de volgende technieken om je code te beheren in Databricks-notebooks. Sla om te beginnen herbruikbare codesnippets op in aparte notebooks en roep ze aan met %run. Gebruik ook Databricks Utilities (dbutils) voor transformaties. En voor de leesbaarheid is het verstandig PEP 8 (Python) of SQL-best practices te volgen. Gebruik altijd markdown-cellen voor toelichting.

-- Select customer_id and calculate total revenue per customer
SELECT customer_id, SUM(total_amount) AS revenue  
FROM sales_data  
-- Group results by customer to get total revenue per customer
GROUP BY customer_id  
-- Order customers by revenue in descending order (highest first)
ORDER BY revenue DESC  
-- Return only the top 10 customers by revenue
LIMIT 10;Mogelijk gemaakt door

Loop je tegen problemen aan tijdens het werken met Databricks-notebooks, dan kun je de volgende methoden gebruiken voor troubleshooting:

• Cluster loopt vast? Herstart de kernel (Run → Clear State & Restart).

• Langzame uitvoering? Controleer de Spark UI (Cluster → Spark UI) op knelpunten.

• Versieconflicten? Gebruik %pip list om afhankelijkheden te controleren.

Gebruik de volgende sneltoetsen voor sneller coderen:

• Shift + Enter → Run de huidige cel.
• Ctrl + / → Geselecteerde regels (un)commentariëren.
• Esc + A/B → Nieuwe cel hierboven/onder toevoegen.

Use cases en scenario’s uit de praktijk

Databricks-notebooks worden veel gebruikt in data engineering, machine learning en business intelligence. In deze sectie belicht ik praktijkcases en codefragmenten die laten zien hoe teams Databricks-notebooks inzetten voor productie-workflows.

Casus 1: ETL-pipelines voor data engineering

Stel: een retailbedrijf haalt ruwe verkoopdata binnen, schonen die op en slaat ze op in een Delta Lake voor rapportage. Het proces ziet er als volgt uit:

• Stap 1: Lees ruwe data in vanaf cloudopslag.
• Stap 2: Reinig en transformeer data met PySpark.
• Stap 3: Sla opgeschoonde data op in een Delta-tabel.
• Stap 4: Plan het notebook als een job.

Dit proces verbetert de betrouwbaarheid van data en de queryprestaties voor rapportage. Het onderstaande codefragment is een voorbeeld van hoe je de bovenstaande oplossing kunt implementeren:

# Read raw sales data from cloud storage
df = spark.read.format("csv").option("header", "true").load("s3://sales-data/raw/")

# Data cleaning and transformation
df_cleaned = df.filter(df["status"] == "completed").dropDuplicates()

# Save to Delta Table for analysis
df_cleaned.write.format("delta").mode("overwrite").saveAsTable("sales_cleaned")Mogelijk gemaakt door

Casus 2: Ontwikkeling van machine learning-modellen

Nog een scenario: een financiële instelling voorspelt wanbetalingen op leningen met een ML-model. Om deze workflow in een Databricks-notebook te implementeren, volg je de onderstaande stappen. Dit resulteert in geautomatiseerde modeltracking en deployment met MLflow.

• Stap 1: Laad en preproces leningdata.
• Stap 2: Train een logistieke regressie met MLflow.
• Stap 3: Registreer en track het model.

# import libraries
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import mlflow

# Load and prepare data
df = spark.read.table("loan_data").toPandas()
X_train, X_test, y_train, y_test = train_test_split(df.drop("default", axis=1), df["default"])

# Train model
model = LogisticRegression()
model.fit(X_train, y_train)

# Log model in MLflow
mlflow.sklearn.log_model(model, "loan_default_model")Mogelijk gemaakt door

Casus 3: Ad-hoc data-analyse voor business intelligence

In een scenario waarin een marketingteam klantbetrokkenheidstrends analyseert, implementeer je de oplossing in de volgende stappen:

• Stap 1: Query klantgedragsdata met SQL.
• Stap 2: Maak interactieve visualisaties.

Dit proces leidt tot snellere besluitvorming met interactieve dashboards.

%sql
-- Count the number of interactions per customer segment
SELECT customer_segment, COUNT(*) AS interactions  
FROM user_activity  
-- Group by customer segment to aggregate interaction counts
GROUP BY customer_segment  
-- Order results by interaction count in descending order
ORDER BY interactions DESC;Mogelijk gemaakt door

Moet je je kennis van Databricks SQL opfrissen? Lees dan onze Databricks SQL-tutorial om te leren hoe je een SQL Warehouse instelt via de Databricks-webinterface.

Probleemoplossing en veelgestelde vragen

Bij gelijktijdig draaien van Databricks-notebooks kunnen debuggen en prestaties unieke uitdagingen vormen. Hier zijn enkele ideeën om je notebook in productieomgevingen foutloos te houden.

Veelvoorkomende problemen en oplossingen

Hier zijn enkele issues en aanbevolen oplossingen:

• Een notebook dat individueel prima draait, faalt wanneer meerdere gebruikers of jobs het gelijktijdig uitvoeren: Dit kan komen door gedeelde variabelen. Ook kan één cluster meerdere uitvoeringen niet aan. Gebruik widgets voor parameterisatie of cluster autoscaling om voldoende resources te hebben voor gelijktijdige uitvoeringen.

• Een notebook dat eerder snel draaide, duurt nu veel langer: De oorzaak kan liggen in inefficiënte Spark-transformaties die shuffle-problemen veroorzaken of in te veel caches/gepersistede datasets die geheugen gebruiken. Gebruik .persist() en .unpersist() doelgericht. Monitor ook de Spark UI op scheve partitities en optimaliseer queries met Delta-tables.

• %run faalt bij het uitvoeren van een ander notebook: Dit kan gebeuren als het notebookpad onjuist is of als het verwezen notebook afhankelijk is van een niet-beschikbaar cluster. Gebruik absolute paden voor notebook-imports of controleer de clusterbeschikbaarheid en compatibiliteit.

• Een geplande notebook-job faalt: Dit kan gebeuren als het cluster voor uitvoering is beëindigd of als een externe afhankelijkheid faalde, zoals een databaseverbinding of API-call. Schakel clusterherstart bij falen in. Zet in jobinstellingen Retry on Failure aan. Gebruik ook Try-Except-blokken voor externe calls.

Lees onze tutorial Mastering the Databricks API om te leren hoe je de Databricks REST API gebruikt voor jobplanning en het opschalen van geautomatiseerde pijplijnen.

Best practices voor het onderhouden van notebooks in productie

Gebruik de volgende technieken om Databricks-notebooks in productie te onderhouden:

• Modulariseer code in herbruikbare notebooks: Breek grote notebooks op in kleinere, herbruikbare units en gebruik %run om ze aan te roepen. Sla helperfuncties op in aparte utility-notebooks.

• Gebruik versiebeheer (Git-integratie): Schakel Databricks Repos in om wijzigingen te tracken en versies terug te draaien.

• Optimaliseer clusterauswahl voor jobs: Gebruik jobclusters in plaats van interactieve clusters voor geplande runs.

• Implementeer logging en alerts: Gebruik dbutils.notebook.exit() om jobstatus te loggen. Je kunt ook e-mailalerts configureren in de Jobs-UI om teams te informeren bij fouten.

• Documenteer code en gebruik Markdown voor duidelijkheid: Gebruik markdown-cellen om workflowstappen en logica te beschrijven.

Conclusie

Wil je de basisconcepten van Databricks verkennen, dan raad ik je van harte onze cursus Introduction to Databricks aan. Deze cursus geeft je het juiste fundament om daarna te experimenteren met geavanceerde functies zoals magic commands, parameterisatie en prestatie-optimalisaties. Tot slot is het ook de moeite waard om te leren hoe je een Databricks-certificering behaalt. Ons artikel helpt je de carrièremogelijkheden te verkennen en de juiste certificering te kiezen voor jouw doelen.