Top 4 Exciting New Features in Python 3.9 for AI & Machine Learning

Python has long been the go-to language for AI and machine learning thanks to its simplicity, versatility, and rich ecosystem of frameworks and libraries like NumPy, TensorFlow, and PyTorch. With the release of Python 3.9 in October 2020, the language gets even better for AI/ML with powerful new features and optimizations.

In this article, we‘ll take a deep dive into four key Python 3.9 enhancements that are especially impactful for AI/ML development:

1. Dictionary merge operators for config handling
2. Annotated types for more expressive ML pipelines
3. New string parsing for NLP data cleaning
4. Time zone support and other performance boosts

We‘ll explain each new feature with code samples and discuss how it can make your AI/ML projects cleaner, faster, and more robust.

Dictionary Merge Operators for Simpler Config Management

Machine learning code often involves working with complex nested dictionaries to specify model architectures, hyperparameters, and other configurations. The new dictionary merge | and update |= operators in Python 3.9 are a game-changer here.

For example, let‘s say you have separate dictionaries for your default model config and custom hyperparameters:

default_config = {
    ‘model‘: ‘resnet50‘,
    ‘lr‘: 0.001,
    ‘batch_size‘: 32
}

custom_hparams = {
    ‘lr‘: 0.0001,
    ‘epochs‘: 100
}

Previously, merging them required clunky unpacking syntax:

# Python 3.8
config = {**default_config, **custom_hparams}

Now in Python 3.9, it‘s a one-liner:

# Python 3.9
config = default_config | custom_hparams

You can use the update operator to modify configs in-place – handy for sweep jobs:

config = default_config.copy()
config |= custom_hparams

This is just scratching the surface. With more complex setups involving multiple config files, possibly loaded from YAML/JSON, these operators really streamline config handling. No more manual dict unpacking!

Annotated Types for Safer, Self-Documenting ML Pipelines

Python‘s dynamic typing offers flexibility for fast experimentation, but some AI/ML codebases can grow unwieldy without strong typing to reign things in. That‘s where Python‘s type hinting comes in – it allows specifying expected types for function arguments and returns while retaining dynamic runtime behavior.

Python 3.9 takes this a step further with the new Annotated type, which allows augmenting type hints with additional metadata. This is especially powerful for ML pipelines with complex data flows.

For instance, suppose we have a pipeline stage that scales numeric features to a specific range:

def scale_features(
    X: Annotated[NDArray, "2D array of numeric features"], 
    range: tuple[float, float] = (-1.0, 1.0)
) -> Annotated[NDArray, "Scaled to (min, max)"]:
    X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
    return X_std * (range[1] - range[0]) + range[0]

Here we‘ve annotated both the input X and the return type with additional details on their expected shapes and value ranges. This makes the pipeline more self-documenting and allows for more specific validation and testing.

We can further augment our type hints with unit metadata:

from typing_extensions import Annotated
from my_ml_lib import NDArray, Units

def predict_power_output(
    temp: Annotated[NDArray, Units.CELSIUS], 
    humidity: Annotated[NDArray, Units.PERCENT]
) -> Annotated[NDArray, Units.MEGAWATTS]:
    ...

Defining reusable Units types makes our code‘s physical assumptions crystal clear, helping avoid silent bugs from mismatched or improperly scaled units. More advanced linter and analysis tools can potentially catch such issues before runtime.

Fast, Safe String Parsing for NLP Data Wrangling

String data is the lifeblood of NLP. Python‘s new removeprefix() and removesuffix() methods in 3.9 make it easier to quickly parse and clean text data.

Say we‘re parsing medical records and want to extract BP readings from raw notes like "BP: 120/80 mmHg":

readings = [
    "BP: 120/80 mmHg",
    "BP: 130/85",
    "BP= 125/82 mm Hg",   
]

The removeprefix() method offers a safe, concise way to extract just the numbers:

import re

bp_values = []
for reading in readings:
    bp_str = reading.removeprefix("BP:").removeprefix("BP=")
    bp_str = re.sub(r"mmHg", "", bp_str)
    bp_values.append(bp_str.strip())

print(bp_values)
# [‘120/80‘, ‘130/85‘, ‘125/82‘]

The removesuffix() method works similarly. These are small but welcome improvements over more cumbersome approaches using str.replace(), regex, or string slicing, which can inadvertently mangle input data. When processing large text corpora, those saved keystrokes and memory copies can really add up!

Time Zone Aware Datetime Handling and Performance Boosts

Time series data is ubiquitous in AI/ML applications, and dealing with datetime values across time zones and daylight saving policies can quickly get thorny. The new zoneinfo module in Python 3.9 brings first-class IANA time zone database support, making it much easier to work with localized datetimes:

from datetime import datetime
from zoneinfo import ZoneInfo

# Create time zone-aware datetime 
ny_time = datetime(2021, 8, 15, 12, 0, 0, tzinfo=ZoneInfo("America/New_York"))

# Convert to another time zone
la_time = ny_time.astimezone(ZoneInfo("America/Los_Angeles"))

Having reliable time zone conversions baked into Python eliminates the need for third-party libs like pytz, making time series modeling code more portable and maintainable. This will be a huge timesaver (pun intended) for data scientists and ML engineers!

Python 3.9 also brings major performance enhancements under the hood. The new PEG parser allows for parsing Python source up to 10% faster, while many core operations on built-in data types like list and dict benefit from speedups and memory optimizations. These improvements compound at scale – great news for data-heavy AI/ML workloads.

The Future of Python and AI/ML

Python adoption continues to surge in the AI/ML community. The 2020 State of ML survey by Kaggle found that 90% of data scientists and ML engineers use Python daily, far eclipsing other languages like R, C++, and Java.

As Python‘s ecosystem matures, it‘s planting firm roots in production use cases as well. A 2021 Forrester survey found that 50% of enterprises have adopted ML, with Python leading as the language of choice. With the release of Python 3.9 and continued improvements in tooling and scalability, this trend shows no signs of slowing.

Python 3.9‘s new features are another step in the right direction, making the language even more expressive and performant for the rigors of modern AI/ML development. While some enhancements like dictionary merge operators are broad quality-of-life improvements, others like Annotated types have outsize impact in AI/ML contexts due to the field‘s acute need for more robust pipelines and speedier iteration.

Looking ahead, the Python community has even more in store to solidify Python‘s AI/ML dominance. Ongoing projects like Python‘s faster CPython runtime, Cython static compiler, and Pyston/Pyjion JIT compilers all aim to elevate Python‘s baseline speed closer to that of C/C++. Expect to see these reflected in more performant scientific computing libraries soon.

Python‘s type hinting system is also steadily progressing, with more granular static analysis, runtime checking, and editor integration. Exciting developments like Dask and Modin are making Python more feasible for terabyte-scale datasets, while initiatives like ONNX and NNVM are standardizing model exchange between various Python deep learning frameworks.

The future of AI and ML is inextricably tied to Python, and Python 3.9 is a significant milestone in that journey. By using Python 3.9‘s new features today, data scientists and ML engineers can more effectively tackle the central challenges of AI/ML – from wrangling massive real-world datasets to deploying robust, large-scale models – with the familiar, eminently readable syntax they know and love. And Python‘s story is still just beginning – its stability and versatility make it the ideal substrate to host the next generation of AI breakthroughs. I, for one, can‘t wait to see what the Python AI/ML community achieves next.