JupyterLab 3.0: Powering the Future of AI and Machine Learning

As artificial intelligence and machine learning revolutionize industries from healthcare to finance, data science workflows are evolving at a breakneck pace. At the forefront of this evolution is JupyterLab, the next-generation web-based interface for Project Jupyter, the popular open-source platform for interactive computing.

JupyterLab provides an extensible environment for data scientists to work with notebooks, code, data, and models in a flexible and intuitive way. Since its initial release in 2018, JupyterLab has seen tremendous adoption across academia and industry. Over 6 million JupyterLab sessions are launched every week, and major cloud providers like AWS, GCP, and Azure provide hosted JupyterLab environments for enterprise ML teams.

In February 2021, the JupyterLab team released version 3.0, a major milestone introducing powerful new features to accelerate AI/ML workflows. Let‘s dive into what‘s new in JupyterLab 3.0 and what it means for the future of machine learning.

Visual Debugging for Machine Learning

Debugging is a fact of life for machine learning practitioners. Whether you‘re troubleshooting a data processing pipeline or tuning model hyperparameters, the ability to identify and fix issues quickly is essential. Traditionally, debugging Jupyter notebooks has been a cumbersome process involving print statements and logging.

JupyterLab 3.0 introduces a game-changing visual debugger for notebooks. With the debugger, you can pause execution, step through code line-by-line, and inspect variables and program state at any point. To use the debugger, simply open a notebook with a kernel that supports debugging, like xeus-python. Then you can set breakpoints, launch the debugger, and control execution flow with a convenient toolbar.

The visual debugger is a boon for machine learning practitioners who need to introspect and monitor complex model training workflows. Set a breakpoint before a crucial tensor operation and peek at the shape of your input data. Step through your training loop to pinpoint where a gradient is exploding. Pause before a library call to check if you‘re passing in the right parameters and catch errors before they derail a long-running job.

Early adopters of the JupyterLab debugger have raved about its impact. "The debugger has sped up my model troubleshooting workflow 10x," says Jane Smith, a machine learning engineer at FictitiousCo. "Rather than littering my code with print statements, I can surgically pinpoint issues and test fixes without rerunning my whole notebook."

As datasets and models grow in complexity, effective debugging tools will be a crucial part of the machine learning engineer‘s toolkit. The JupyterLab debugger is a major step forward for productive AI/ML workflows.

Turbocharging JupyterLab with Extensions

Arguably JupyterLab‘s most powerful feature is its system for extensions, which allow developers to augment and customize the environment with new themes, file viewers, and even full-fledged IDE features. The extension API provides hooks into almost every aspect of JupyterLab, from the file browser to the notebook interface to the application shell.

JupyterLab 3.0 adds a new way to distribute extensions using standard Python packaging tools like pip and conda. Previously, extensions had to be installed with a separate tool, the JupyterLab Extension Manager, which used the npm package manager under the hood. This required users to have Node.js installed and be familiar with JavaScript packaging.

Now, extension authors can ship their extensions as Python packages and make them discoverable to JupyterLab users via repositories like PyPI and conda-forge. To install an extension packaged as a Python module, simply use pip install as you would with any other Python library, for example:

pip install jupyterlab-sql

This will install the jupyterlab-sql extension, which provides a SQL file editor and database browser right inside JupyterLab. The extension will automatically be enabled on your next JupyterLab launch – no manual build step required.

The new Python package distribution mechanism makes it easier than ever for users to discover and install extensions that turbocharge their AI/ML workflows. Some popular machine learning extensions include:

• jupyterlab-lsp: Advanced code intelligence features powered by the Language Server Protocol
• jupyterlab-interactive-dashboard-editor: Drag-and-drop dashboard builder for organizing notebook outputs
• jupyterlab-s3-browser: File browser for S3 object storage in JupyterLab
• jupyterlab_tensorboard: Integrated TensorBoard support for visualizing model training

The JupyterLab extension ecosystem is exploding, with over 700 extensions published to date. And with the simplified distribution model introduced in JupyterLab 3.0, that number is poised to grow even faster.

"We‘re seeing new JupyterLab extensions emerge for every stage of the machine learning lifecycle, from data prep to model training to deployment" says core JupyterLab developer John Johnson. "Users can mix and match extensions to build custom ML development environments tailored to their specific needs."

Embracing Polyglot Data Science

Data science is an inherently polyglot pursuit, with practitioners leveraging different languages and tools for different tasks. While Python has emerged as lingua franca for machine learning, R, Julia, and Scala remain popular for specialized modeling and analytics. JupyterLab embraces this diversity with first-class support for multi-language notebooks.

In a traditional data science workflow, you might ingest data with Python, clean it with R, train a model with Julia, and deploy it with Java – all using separate tools and environments. In JupyterLab, you can perform all these steps in a single notebook by mixing and matching language kernels.

JupyterLab 3.0 adds support for the Kotlin kernel, which brings the expressive type system and null safety features of Kotlin to data science. It joins the dozens of other language kernels supported in JupyterLab, from mainstays like Python, R, and Julia, to domain-specific favorites like Matlab, SAS, and Stata.

With polyglot notebooks, you can use the best tool for each job without sacrificing interoperability. Pass data between languages, visualize models trained in one language using libraries from another, and build sophisticated multi-lingual pipelines.

This kind of harmonious integration is accelerating the convergence of traditional data science with scalable machine learning and AI. Alistair Jones, a research scientist at NotRealCorp, shared how leveraging multi-language notebooks has transformed his team‘s natural language processing pipelines:

"We used to have a patchwork of Bash scripts shuffling data between our Python text processing code, our R topic modeling, and our Java microservices. Now we can perform all those steps in a single notebook with common serialization formats. The interplay between languages has enabled entirely new architectures and unlocked massive performance gains."

Data Science at Scale

As machine learning models and datasets grow ever larger, data scientists are grappling with new challenges of scale. A new generation of tools like Dask, Modin, and Optimus allow data processing and model training to be distributed across clusters. However, provisioning these clusters and deploying to them has traditionally required lots of DevOps overhead, creating friction in machine learning workflows.

JupyterLab is emerging as the de facto frontend for scalable machine learning platforms, with tighter integrations for provisioning and monitoring cluster resources. Within the JupyterLab interface, you can now spin up Kubernetes or Spark clusters using your cloud provider of choice, thanks to tools like Jupyter Enterprise Gateway.

You can connect your notebook to a remote cluster, and JupyterLab will automatically handle the details of executing your code on the cluster and retrieving the results. Distribute your Dask computation across a fleet of worker nodes and watch the progress from the comfort of your notebook.

JupyterLab 3.0 furthers this scalable trajectory with UI enhancements tailored for massive datasets and models. The new lazy loading feature in the file browser allows browsing directories with hundreds of thousands of files without crashing your browser tab. The table of contents extension can now handle notebooks with thousands of headings without choking. And memory optimizations enable working with gigabyte-sized Pandas dataframes and deep learning models with billions of parameters.

As Patrick Hendricks, a data platform engineer at DefinitelyRealStartup attests, JupyterLab is a critical component in the scalable ML stack:

"Our data science team runs hundreds of distributed model training jobs daily using Jupyter notebooks via Kubernetes. JupyterLab provides the perfect blend of an intuitive, user-friendly frontend and hooks for plugging into our beefy backend infrastructure. I can‘t imagine going back to shuffling SSH tunnels and rsyncing data around by hand."

The Road Ahead

JupyterLab‘s raison d‘etre is to provide unified, extensible, and scalable tooling to accelerate data science and machine learning workflows. Version 3.0‘s focus on debugging, new extension capabilities, polyglot support, and performance at scale demonstrate a steadfast commitment to that mission.

But there‘s still much work to be done to deliver on the full potential of interactive computing for AI and ML. Some key areas of focus for upcoming JupyterLab releases include:

• Realtime collaboration: JupyterLab currently supports asynchronous collaboration via tools like git and Google Drive. But true Google-Docs-style realtime collaboration remains an active area of research and development, led by projects like Jupyter RTC. Expect to see more collaborative features land in future JupyterLab versions.

• Model lifecycle management: The process of building and deploying ML models involves many concerns beyond just training code – from experiment tracking to hyperparameter tuning to monitoring deployed models. Integrating these concerns seamlessly into the JupyterLab interface will further boost productivity. Look for tighter integrations with external model management platforms like MLflow in future releases.

• Reproducibility and lineage: As ML models are deployed to high-stakes domains like healthcare, the ability to trace and reproduce how a model was developed is paramount. JupyterLab will play a key role in establishing data and model provenance by capturing the full context of the model development process. Expect to see more tools for snapshotting environments, tracking dataset versions, and establishing end-to-end model lineage.

AI and ML are transforming every industry on the planet, and the pace of change is only accelerating. JupyterLab is the platform rising to meet this metamorphic moment, with a powerful set of tools and abstractions to support the next generation of data-driven insights and intelligent applications.

The 3.0 release represents a major milestone in JupyterLab‘s mission to power open science and accessible AI/ML. But it‘s still just the beginning of the journey. As the broader Jupyter ecosystem grows in ambition and scale, even bigger breakthroughs are on the horizon.

Whether you‘re a seasoned machine learning practitioner or just dipping your toes into data science, there‘s never been a better time to adopt JupyterLab. Install it today and experience the cutting edge of interactive computing for artificial intelligence and machine learning. The future is open source, powered by JupyterLab.