Python’s Global Interpreter Lock (GIL) has long been a barrier for scientific computing, limiting the ability to fully utilise multi-core hardware and scale parallel workloads. With the introduction of free-threaded Python (PEP 703), this constraint is finally being lifted. Several core scientific Python packages (including NumPy, SciPy, and pandas) have already begun transitioning to support users who wish to use free-threading, paving the way for improved performance and concurrency for the broader ecosystem. This talk will explore what free-threading means for the scientific Python community, discuss the technical challenges in adopting this new paradigm, and highlight the practical impact it can have for users and maintainers. Attendees will receive actionable guidance for leveraging free-threading in their projects, including insights into the transition process and lessons learned from early adopters.
Contaminated groundwater often carries multiple dissolved chemical species that react with each other, potentially causing mineral precipitation and altering subsurface flow properties. Simulating these coupled processes requires modeling groundwater flow, multi-species solute transport, and geochemical reactions simultaneously. This talk presents rtmf6, a new open-source reactive transport model that couples MODFLOW 6 (groundwater flow and transport) with PHREEQC 3 (geochemical reactions) through the Python libraries pymf6 and PhreeqPy. A key design goal was parallelization: species transport runs as independent parallel processes, while geochemical computations use multi-threading. Benchmark results show good agreement with the established model PHT3D, while rtmf6 supports a substantially broader range of applications by leveraging the full capabilities of MODFLOW 6.
The intrinsic difficulties related to gathering and processing astronomical data have traditionally branded it a “data starving” field. The situation changed only in the last few decades with the advent of large scale sky surveys that made publicly available the first extremely large and coherent astronomical data sets. In this context, Python has played a crucial role in enabling an extremely fast development of tools among the astronomical community, thus fostering an unprecedented revolution on how experts interact with their data. In this talk, I will describe the first stages of astronomical data analysis, how new data challenges were imposed in the last century and how Python was crucial to change the paradigm of astronomical data analysis. Finally, I will discuss the new framework of astronomical data and the impact of python developed tools in the process of scientific analysis. Finally, I will highlight the most challenging issues still to be faced in the era of the surveys like the Vera C. Rubin Observatory, as well as the impact of foundation models in the scientific exercise of astronomical discovery.
Parallel programming can be intimidating, but doesn’t need to be! Tile-based programming models make GPU parallelism more newcomer-friendly, highly productive, and still fast by letting you write sequential, array-centric code while the framework handles parallelization, synchronization, and data movement.
In this example-driven talk, we’ll introduce tile-based programming in Python using NVIDIA’s new stack: cuTile and its compiler foundation, Tile IR. You’ll see recently announced CUDA Tile capabilities in action, including multi-GPU communication, interoperability with traditional CUDA SIMT, and support for more diverse kernels such as convolutions and stencils. We’ll compare tile and SIMT approaches, build intuition for performance and execution, and demonstrate practical debugging and reasoning techniques. Along the way, you’ll see real workloads: HPC stencils, an SPMV plus CG solver, and ML models from TileGym. You’ll leave with a clear sense of when tile programming helps, and how it enables more portable high-performance Python as hardware trends evolve.
Foundational Python libraries provide critical functionality that diverse communities of downstream developers and users depend on, yet the teams maintaining these libraries must make hard choices about where to spend limited resources. Often, gaps in awareness between a core project and its broader community silently erode trust, collaboration, and sustainability. This talk shares lessons from a community-driven sustainability initiative to (re)-connect napari—a foundational library for interactive, multi-dimensional image and data viewing built on the scientific Python stack—with its ecosystem of over 580 community-developed plugins. Napari plugins are built and used by scientists, from complete Python novices to cutting-edge code experts, from the biological to physical to social sciences, and beyond. Through a working group that brought together the napari core team, plugin developers and end users, the plugin sustainability initiative discovered that new avenues for communication and collaboration lead to shared ownership of the ecosystem's progress. This talk will discuss what engagement approaches worked, what has not worked, what surprised us, and what any Python project with downstream developers can take away about sustainably growing and maintaining a community and its software ecosystem.
In Fall 2025, the UConn School of Mechanical, Aerospace, and Manufacturing Engineering launched Open Source Experiences, an elective course developed in partnership with six NumFOCUS-supported projects (napari, BiocPy, Blosc, MNE-Python, mlpack, JuliaHub). The course embedded students directly into active open source communities, where they contributed to the codebases, collaborated with project maintainers, and learned about community-driven open source software development. In this talk, we will share the lessons learned from piloting this collaboration model, and how these experiences benefit students, open source and open science communities, and educators alike. Attendees will take away actionable insights for integrating open source contributions into their own classrooms and programs.
Scientific organizations struggle to extract actionable insights from publication data tagged with inconsistent and noisy keywords. Transforming hundreds of thousands of such keywords into a 110,000+ concept, semantically consistent taxonomy, and attaching them hierarchically at scale, requires more than ad-hoc normalization: it demands careful system design.
This talk presents a production-grade pipeline that extends OpenAlex's 4-level framework (Domain → Field → Subfield → Topic) with a granular Concept layer, resulting in a 5-level scientific taxonomy. The system combines SPECTER2 embeddings to model semantic similarity, Leiden graph clustering to group 100K+ concepts, and Qdrant for efficient vector-based hierarchical attachment.
A central contribution is a strategic, multi-stage integration of LLMs. Rather than using LLMs end-to-end, we deploy them at 5 targeted points where semantic judgment matters most: concept granularity filtering, field classification across 26 domains, cluster renaming, explanation generation and validation of topic assignments using multi-embedding comparisons. Deterministic methods ensure scalability and reproducibility, while LLMs provide semantic precision where embeddings alone fall.
The resulting taxonomy is used in production to automatically tag millions of publications, enabling real-time trend detection and portfolio-level analytics that support strategic decision-making.
Galaxy clusters are the largest gravitationally bound structures in the universe, shaped by both the overall composition of the cosmos and the complex physics of the gas within them. Disentangling these two influences is a central challenge in modern astrophysics, and key to resolving cases where different experiments measuring the same fundamental properties of the universe yield conflicting results, pointing to new physics.
Telescopes such as eROSITA, the Simons Observatory, CMB-S4, Euclid, and the Rubin Observatory are now observing clusters across multiple wavelengths at unprecedented depth, making this challenge urgent and tractable.
We present a likelihood-free inference framework combining Gaussian process emulation (CARPoolGP) with neural networks to jointly infer 28 cosmological and astrophysical parameters from stacked cluster profiles. The emulator, trained on 768 hydrodynamic zoom-in simulations (CAMELS-zoomGZ), generates low-variance predictions across the full parameter space. Neural networks, optimized via Optuna, map emulated multiwavelength profiles to posterior moments.
We achieve correlation coefficients above 0.97 for all cosmological parameters and above 0.90 for all astrophysical ones, with robustness to realistic noise levels. This accuracy across a full 28-dimensional parameter space is unprecedented, allowing us to separate cosmology from internal cluster physics, enabling more reliable cosmological measurements and better-calibrated simulations.
In this talk I share stories from the surprisingly challenging experience of modernising the LinearOperator data structure in SciPy to include support for batched input and alternative array types. Come and hear what it is like to learn the intricacies of an 18 year old data structure from scratch in order to be able to add new features without breaking the world!
In this talk, I will share some highlights from the development of the PyPartMC package (https://pypi.org/p/PyPartMC; https://pypi.org/project/PyPartMC) in which we have just celebrated our 100-th release!
PyPartMC constitutes Python bindings to the Fortran-implemented internals of the PartMC aerosol dynamics Monte-Carlo simulation package developed at the University of Illinois Urbana-Champaign.
Rather than providing "wrappers" to highest-level PartMC interface, PyPartMC leverages the object-oriented architecture of PartMC and offers bindings to numerous datatypes and routines, as well as examples of how to construct simulation logic with these components in Python.
Applications of PyPartMC concern air-pollution and aerosol-cloud interactions modelling, and range from process studies to HPC applications via coupling with Numerical Weather Prediction models.
The talk will be addressed primarily to Python package developers. I will share the lessons learned, some fun facts, and practical solutions which are applicable to any Fortran-to-Python bindings project.
We will go through the key design goals of the project: maintainability, exposing internals, CI and automation, complete test coverage and single-click operations on Google Colab and within Matlab.
I will cover the encountered technical challenges - both solved and remaining - welcoming new contributors to the project.
This talk will introduce scikit-learn users to the new API for metadata routing, a feature introduced in the recent releases available in experimental mode. As a scikit-learn core developer, I'll share insights from my experience working directly on this feature.
We will explore what metadata is, how it can be used in machine learning pipelines, and how the new API simplifies routing metadata throughout a workflow. Routing metadata refers to an internal mechanism to pass metadata around between components of a data science pipeline, ensuring it reaches the functions that consume or utilize it.
Using well-known metadata such as sample_weight and groups which are implemented in many scikit-learn metrics and evaluation tools, we will examine the restrictions for passing metadata prior to the introduction of the new API. Then, we will enable the new routing API and demonstrate how it solves these challenges with examples that involve layers of nested-ness through cross-validation, hyperparameter tuning, or pipelines. We will explain the core components of the API, including methods like set_fit_request() and how to actually pass our metadata.
Attendees will leave with an understanding of how to enable and use the new routing API including passing metadata through Pipeline objects and validation tools like cross_validate. Additional references to the metadata user guide and developer guide will be provided for those interested in further exploration.
The Mauve Space Mission is a 16u smallsat, designed by Blue Skies Space, for studying stars in UV and visible wavelengths. It is a first of its kind private space mission, doing deep space observations. Mauve’s primary method of pointing at its desired target is through two star trackers. However, the star trackers are not perfectly aligned with the telescope boresight which can cause the target to not be centred. Measurements from the detector can be used by on-board software to help correct this misalignment and keep the boresight focused on the target.
This talk will look at the role Python played in the development of some of Mauve’s onboard software, from a proof of concept simulator through to the flight code currently operating in orbit. I will discuss the challenges during development, including constraints from the satellite manufacturers, and consider if Python is the right tool for onboard software.
Model Context Protocol (MCP) was created by Anthropic, donated to the Linux Foundation in December 2025, and is now the industry standard adopted by OpenAI, Google DeepMind, and thousands of developers. MCP gives every AI model a single universal way to connect to tools, data, and services. This talk shows Python engineers how to build a fully functional FastMCP server from scratch, expose tools/resources/prompts, connect to Claude Desktop and Claude Code, and deploy a production MCP server. Cover security best practices and the anti-patterns that get you hacked. You'll leave with a clear mental model of the MCP ecosystem, a reusable FastMCP project scaffold, and the confidence to make any Python service AI-ready.
Your GPU is fast, so why does your Python code still feel slow? This talk shows a practical, Python-first profiling workflow with Nsight Systems, Nsight Compute, and NVTX for CuPy, Numba, PyTorch, JAX, and CUDA extensions. We will use timelines to find launch overhead, hidden synchronizations, and host-device copies, then drill into kernel bottlenecks like memory throughput and occupancy. You will leave with a repeatable loop for turning profiles into measurable speedups.
Mapping freeform research affiliations to persistent identifiers such as ROR (Research Organization Registry) is harder than it looks. Institution names appear in many forms such as abbreviations, alternate spellings, local languages, or legacy names, thus making a reliable mapping difficult to achieve at scale.
In this talk, we present a semantic retrieval pipeline that reframes institution identification as a search problem rather than a string-matching task. Our system combines named entity recognition to extract institution entities, dense embeddings to represent their semantic meaning, and vector search to retrieve the most likely ROR matches. This approach allows us to handle noisy, incomplete, and multilingual inputs while remaining resilient to variation in how institutions are referenced.
By treating institution matching as semantic retrieval, we improve recall and robustness without relying on heuristics or on a continuous expanding rule-based approach. The system scales naturally as new institutions are added and as naming conventions evolve, making it well suited for the dynamic research environment.
We will share implementation details, evaluation results, and practical lessons learned from deploying this pipeline in a real-world production setting.
Scaling data science pipelines in research and industry poses well-known maintainability challenges (big ball of mud). Research codebases must support rapid iteration as insights evolve, while industry systems must scale amid changing business needs and organizational complexity. Effective projects should remain maintainable without overhauling the entire code base for each change. Ideally, evolving from a notebook experiment to a production-grade application should feel natural, with minimal overhead.
In this talk, we show how data science projects benefit from established software engineering principles, particularly those inspired by functional programming, in Python. The first part of the talk outlines the design principles. The second part, will go into our (brutally honest) insights from applying these in various research projects, spanning from master student experiments to the applications in our R&D teams.
When writing Python code for scientific applications, you may reach a point where you want to share your work with collaborators that don't code. But what if you do not want to require them to set up Python environments or act as their tech support?
There are tools to avoid that by converting your Python code into executable that can be run without Python setup, and with all dependencies included.
In this talk I will share my experience with using some of those tools like PyInstaller and Conda constructor and how you could do the same.
Showed solutions might be used for both CLI script and application with graphical Interface.
Importantly, I will also mention some of the callenges that you might encounter and how to solve them.
Python has become the most widely used language in scientific computing and data science due to its approachable syntax, vast ecosystem of libraries, and rapid prototyping capabilities. However, its interpreted nature often poses a performance bottleneck for computationally intensive tasks common in High Performance Computing (HPC) used in scientific and data work, such as large-scale simulations, complex data analysis, and machine learning model training.
Enhancing Python's performance, therefore, is critical for scientific computing: it allows researchers and engineers to maintain the productivity and flexibility of the Python environment while achieving the necessary speed and scalability to tackle demanding, real-world HPC problems without needing to switch to lower-level languages entirely.
The 2D constrained drawing workbench "Sketcher" forms the backbone of more complex models created in FreeCAD, an open source 3D parametric modeling software. The "planegcs" solver used in Sketcher can handle a large number of constraints (like dimensions, angles, equality, coincidence, etc.), but it is practically impossible to have all that one might need (e.g. making one line segment 2.5 times the length of another). While it is possible to employ the Spreadsheet workbench for a larger set of options, it can get fairly clunky quickly. Here, I propose and discuss the progress in another approach: creating custom constraints directly in Sketcher that can directly be used by the solver, as well as its scriptablility with Python.
Skrub is a package that eases preparing dataframes so they can be used in machine-learning tasks. In practice, data can be spread over multiple tables, represent various types of information (tabular, textual, graphical), or be stored on external database systems rather than dataframes.
Skrub Data Ops help with constructing versatile pipelines that can handle this variety of scenarios, while at the same time avoiding data leakage and allowing to build rich hyper-parameter grids that can be explored to maximize the performance of the final machine learning model.
In this talk, we give a brief introduction of the Data Ops framework before presenting three separate use cases highlighting their versatility: a traditional machine learning pipeline that uses Optuna to perform hyper-parameter tuning, a pipeline that trains on data stored in a relational database rather than a dataframe, and an image classification task with Pytorch.
By the end of the talk, attendees will learn about the skrub Data Ops, their main features and how they can be used successfully in different practical scenarios.
Slides are now available here!
In the field of non-destructive testing, the French Alternative Energies and Atomic Energy Commission (CEA) entrusted CODRA with the specification and development of software for the automatic reconstruction of radiographic scenes from partial X-ray images.
The challenge was to assemble a full-field X-ray scene from multiple acquisitions obtained by moving a detector or juxtaposing imaging plates, without any prior metadata regarding position, orientation, or magnification.
The reconstruction processing pipeline includes several key steps:
- image pre-processing and denoising,
- robust blob detection,
- homography estimation for geometric correction,
- fusion of corrected sub-images into a coherent global scene.
The entire workflow was developed using open-source scientific Python libraries (NumPy, SciPy, scikit-image, OpenCV) and prototyped interactively with DataLab, an open-source platform for signal and image processing. DataLab was remotely controlled to dynamically visualize intermediate results, tune parameters, and validate geometric transformations step by step.
This project illustrates how the scientific Python ecosystem enables the development of industrial-grade imaging software, from interactive prototyping to automated deployment, using 100% open-source components.
Your simulation is 40 hours into a 48-hour SLURM allocation and it has stopped making progress. You can't restart it, and you didn't instrument it. Until recently, Python's official answer was "you should have thought about that earlier." That answer has changed.
Python 3.14 and 3.15 quietly shipped the biggest upgrade to observability in the language's history: a safe, supported way to attach a debugger to any live Python process (pdb -p), and Tachyon, a sampling profiler in the standard library that attaches to a running process with virtually zero overhead and can tell you -- among other things -- which thread is hogging the GIL, at up to a million samples per second.
But scientific Python is observability's hardest case: long-running, thread-heavy, mostly native code underneath, and increasingly on the GPU. I'll demo what the new tools do on live processes, but will also be honest about where they still go dark today -- native frames, free-threaded builds, GPU timelines -- and lay out a plan for Python 3.16, which you can help shape as well.
We first discuss recent developments in SciPy the library, focusing on new features implemented in recent releases and ongoing work. We then survey the road ahead and discuss the roadmap for evolving SciPy forward.
Recent advances in AI have shifted industries’ attention toward integrating LLM-based systems. Even though LLMs can solve a wide range of business problems, they came with a significant complexity overhead. At same time, many real-world business applications involve well-defined objectives, predictable inputs, and clear evaluation criteria.
Today, we are increasingly seeing a default pattern: for almost any NLP use case, teams prompt GPT-like models and pay the bill at the end of the month. However, this approach often introduces unnecessary complexity, costs, and operational risk. Many business and research problems exist in constrained environments that can be solved with simpler techniques, achieving the same or higher success rates.
This talk defends that fine-tuned BERT-based models remain a strong and often superior choice for targeted business use cases that require NLP-based solutions. I propose to present a real, in-production use case where a simple transformer-based classifier demonstrates a more favourable performance-cost trade-off than LLM-based approaches, driven by lower latency, reduced operational complexity, easier fine-tuning, and significantly lower maintenance costs.
The goal of this presentation is not to reject LLMs, but to promote a pragmatic, outcome-driven approach to NLP, where “boring” solutions often deliver the most value.
Many scientific models, from climate systems to neural circuits, are defined as simulators: computer programs that generate data from parameters but provide no tractable likelihood function. This makes them invisible to probabilistic programming languages (PPLs) like PyMC and NumPyro, which require explicit likelihoods for Bayesian inference. Practitioners are forced to choose: make simplifying assumptions about the simulator to use a PPL, or use the real simulator and give up the rich modeling capabilities PPLs offer, such as prior specification, uncertainty quantification and exploitation of hierarchical structures.
We present setu ("bridge"), a JAX-native Python package that closes this gap. setu uses generative neural networks trained on simulated data to learn a neural surrogate of the likelihood. This learned likelihood can then be exported directly into PPLs via a simple API: nle.to_pymc() or nle.to_numpyro(). Once inside a PPL, the full Bayesian toolbox becomes available: hierarchical models, custom priors, posterior predictive checks, and standard MCMC samplers — all running on a simulator that was previously out of reach.
The package follows a clean simulate, train, validate, export workflow, with built-in diagnostics to ensure the learned likelihood is trustworthy before it ever enters a PPL. In this talk, we walk through the motivation, design, and a real-world example showing how a black-box simulator gains full PPL capabilities.
We've developed a python-numba library for splines!
It's more flexible and easier to use than what is implemented in scipy, as well as implementing more basis functions (like exponential basis functions).
Scientific Python Ecosystem offers a wide variety of numerical packages, such as NumPy, CuPy, or JAX. One of the domains that also captures a lot of attention in the community is sparse computing.
In this talk, we will present the current landscape of sparse computing in the Python ecosystem and our efforts to revive/expand it. Our main contributions to the Python ecosystem cover: (1) making a novel Finch sparse tensor compiler and Galley scheduler available for the community, (2) standardizing various aspects of sparse computing. We will show how to use the Finch compiler with the PyData/Sparse package and how it outperforms well-established alternatives for multiple kernels, such as MTTKRP or SDDMM.
Real-world use-cases will show you how, step-by-step, Python practitioners can migrate their code to an Array API compatible version and benefit from tensor operator fusion and autoscheduling capabilities offered by the Finch compiler.
Apart from the existing Julia implementation, the number of sparse backends offered by PyData/Sparse will grow in the future to provide a Python-native alternatives for scipy.sparse and Numba solutions. One of them that is currently under development is finch-tensor-lite, a pure Python rewrite of Finch.jl compiler, meant to make the solution lightweight by dropping Julia runtime dependency while providing the majority of features.
This talk will demonstrate how the PyGambit package for game theory can be used to construct games, and compute their Nash equilibria. Secondly, the talk will demonstrate the DrawTree package and challenges associated with drawing game trees, given the constraints of visualising “information sets” in game theory. Finally, the talk will highlight how PyGambit fits into the broader open-source scientific computing ecosystem for research on games via interoperability with the OpenSpiel framework, which is used for reinforcement learning.
In this talk, I'll live-code an interactive visualization that generates images as numpy arrays. I'll then show how the small application we made can run anywhere: in a native window, embedded in a Qt application, in a notebook, in VS Code, and fully in the browser with Pyodide.
The purpose of this talk is twofold. Firstly, this talk demonstrates how easy and fun it can be to create interactive visualizations. Such applications can also be used for educational purposes, annotation tools, demonstrating research findings, etc.
Secondly, this talk introduces the rendercanvas library, which provides an abstraction for a canvas to render to, with user events going the other way, in the form of simple dicts. Rendercanvas provides two types of contexts for rendering: bitmap (used in this talk) and wgpu (for performant GPU rendering).
In this talk, you'll learn about Pixi and how you can use it to create fast, reproducible, and slick developer experiences across multi-platform, multi-language projects. Furthermore, you'll learn how to use pixi-build to build your own packages and seamlessly integrate building from source into your developer workflows, as well as a bit about how Pixi makes things work behind the scenes. Finally, you'll hear about how big projects like SciPy and NumPy are utilising Pixi to facilitate advanced development and make the world of scientific Python software more secure, while also boosting accessibility and improving the new contributor experience.
LLM-as-a-Judge systems are increasingly deployed in high-stakes settings - screening job applicants, triaging medical cases, assessing credit risk, and flagging legal exposure. As the EU AI Act takes effect in August 2026 with penalties up to €35M for biased high-risk systems, organizations are investing heavily in fairness audits. But passing a bias check does not guarantee fairness. Standard Python fairness pipelines rarely detect this shift. In a controlled hiring experiment on real resumes, we demonstrate how alignment and potentially bias-mitigation techniques can reduce aggregate disparities while redistributing harm across intersectional subgroups.
Scientific organizations struggle to extract actionable insights from publication data tagged with inconsistent and noisy author keywords. Automatically assigning papers to consistent, semantically grounded concepts is essential for reliable trend detection, search, and analytics.
This talk presents a production-grade, two-stage classification pipeline that tags hundreds of thousands of scientific papers against a 110K+ concept taxonomy. Given a fixed hierarchical taxonomy extending OpenAlex's 4-level structure with a granular concept layer, the system combines vector-based retrieval, cross-encoder reranking, and targeted LLM validation to achieve scalable and accurate paper classification.
In Stage 1 (Candidate Retrieval), paper metadata (title, abstract, author keywords) is embedded using SPECTER2 and queried against Qdrant to retrieve a small, high-recall candidate set from over 110,000 concepts. In Stage 2 (Reranking and Filtering), cross-encoder models perform fine-grained semantic matching, while LLMs (Azure OpenAI) are selectively applied to resolve ambiguous cases and produce confidence-scored assignments.
Deployed on millions of publications, the system standardizes noisy keywords and enriches paper metadata with semantically consistent concept tags, enabling downstream analytics at scale.
Background
Modern genomic research increasingly relies on diverse computational analyses, ranging from differential expression studies to single-cell and spatial transcriptomics. However, laboratory scientists often encounter significant hurdles navigating scattered documentation, heterogeneous tool ecosystems, and inconsistent workflows across platforms.
Objective
We present PyCabinet, a comprehensive Python-based analysis platform designed to consolidate the fragmented genomics tool landscape into a unified, accessible framework. PyCabinet aims to provide a “transcriptomics toolbox” that guides researchers seamlessly from raw FASTQ files to publication-ready results.
Approach
PyCabinet offers:
End-to-end workflow integration: A seamless progression from raw sequencing data to advanced downstream analyses.
Modular tool selection: Multiple algorithmic options for each analysis step, allowing researchers to select methods tailored to their data and scientific questions.
Comprehensive analysis coverage: Support for differential gene expression (DEG), gene regulatory network (GRN) analysis using graph neural networks (GNNs), single-cell RNA-seq, spatial transcriptomics, and a continually expanding set of analytical capabilities.
Unified interface: Consistent Python API and comprehensive documentation across all modules, minimizing the learning curve and technical barriers for laboratory scientists.
Learning to code has seldom received the due attention it needs in the history of computing. From undergraduate students to the software engineers, programming is picked up either as a self-taught skill in their own time or, more effectively, by participating in bootcamps or workshops organized by volunteers, research software engineers (RSEs), librarians, and so on. Agentic coding is replacing or could potentially replace as the first choice tool in several programming tasks, and this combines LLMs with tools to ground it such as MCPs and tool-calling. This thought provoking talk, questions whether should we continue teaching programming as we do today or adapt it to today's reality.
During this comprehensive talk, we will discuss how to optimize your spatial data processing using Apache Sedona, a distributed processing engine, and SedonaDB, a powerful data fusion-based database that treats spatial data as a first-class citizen. In this talk, you will understand how to optimize:
- Distributed and non-distributed spatial join
- How to optimize spatial partitioning and reduce data skew
- How to leverage Spatial Apache Parquet and Geoparquet to efficiently store and retrieve data
- Optimizing Apache Sedona Python applications to be more performant and consume less memory, incorporating Apache Arrow and SedonaDB
- Powerful indexing techniques
- Distributed K-nearest neighbor algorithm
I will explain why the knowledge of optimization patterns is important and how understanding Apache Sedona's Python limitations is crucial to making your spatial data pipelines robust and efficient. The last part is to explain when use Apache Sedona and where SedonaDB fits.
Hi! Have you ever run a NetworkX algorithm on a large graph and watched it take… longer than you expected? You look at your machine, see all those CPU cores sitting idle, and wonder — shouldn’t this be faster?
NetworkX is one of the most widely used graph analysis libraries in Python. But as the graph sizes become more realistic and huge, the performance becomes a bottleneck. So what if we could make NetworkX faster — without rewriting it in C, and without giving up its philosophy?
In this talk, I’ll introduce nx-parallel, a backend that brings multi-core parallelism to NetworkX algorithms with the help of Joblib. But parallelism isn’t just a magic switch you turn on. We’ll dig into what actually makes a graph algorithm embarrassingly parallel, why only certain algorithms qualify, and how design decisions determine whether parallelism truly scales.
Python is the standard solution for many machine learning and data science applications, from large cloud systems, to workstations, and even on larger embedded or robotics systems. But as we move down into more constrained environments regular (C)Python starts to be a less good fit.
The MicroPython project provides a Python implementation that is tailored for such environments,
and this makes it possible scale down to microcontrollers with just a few megabytes of RAM (or less!).
As a bonus, MicroPython with WebAssembly also makes lightweight browser applications possible.
In this talk, we will discuss how to combine IoT devices, MicroPython and browser to build stand-alone sensor systems and laboratory gear for physical data science.
Pre- and post-processing of large engineering simulation datasets in some scientific domains often demand performance that pure Python cannot yet deliver, and the general approach within the scientific Python ecosystem for overcoming the performance barrier is the combination of Python with compiled languages.
In this talk, I will share practical insights, experiences, and lessons drawn from the development and maintenance of PyDPF-Core, an open-source library that interacts with a C/C++ backend via a client-server architecture for the processing of large engineering simulation datasets. We will start by discussing the challenges of developing and maintaining such a library and then examine how each of these challenges were solved for PyDPF-Core.
The focus of the talk is on transferrable insights and my goal is for attendees to leave the talk with:
- Knowledge of architectural blueprints that can be applied to their own high-performance python projects, especially those involving the processing of large simulation datasets;
- Patterns for managing complexity in large scientific codebases; and
- Understanding the trade-offs that might be encountered.
Class imbalance is a common challenge in real-world machine learning. This course explores why standard approaches fail and how to build reliable classifiers using scikit-learn's calibration and threshold-tuning tools.
We cover practical solutions including resampling strategies, probabilistic calibration with CalibratedClassifierCV, and decision threshold optimization using TunedThresholdClassifierCV. You'll learn to evaluate models appropriately with calibration curves and confusion matrices.
The course also addresses prevalence shift or in other words when your training data doesn't reflect the target population. We demonstrate weight-based training corrections and post-hoc probability adjustments applicable to any binary classifier.
The material is available here: https://github.com/probabl-ai/calibration-cost-sensitive-learning
Learn how to manage your conda- and pip-based Python dependencies with pixi. With its declarative approach, pixi provides a reliable way for reproducible
Python environments. Its design is based on experiences drawn from tools such as pip, conda and mamba as well as Rust's cargo.
Large Language Models (LLMs) are becoming central to modern applications, yet effectively evaluating their performance remains a significant challenge. How do you objectively compare different models, benchmark the impact of fine-tuning, or ensure your LLM responses adhere to safety guidelines (guard-railing)? This hands-on workshop addresses these critical questions.
In this workshop, you will create practical internet-connected sensors with MicroPython. We will cover the basics of setting up the development environment, both for developing on PC and deploying/developing on a microcontroller device.
Targeted towards those that are already comfortable programming in Python, but that have little exposure to embedded/hardware/electronics.
We will provide some MicroPython-capable hardware to develop against, pre-flashed with MicroPython. You may need to sit together in pairs or small groups for the on-device part.
Prerequisites
Participants must bring:
- Laptop with Linux/MacOS/Windows
- Have Python 3.12+ with virtualenv support installed
- If no USB Type-A on your laptop: USB-C to USB Type A adapter
Quantum technologies, ranging from basic studies of quantum dynamics to new applications in quantum computing, require computational tools that can handle sophisticated use cases but are accessible for everyone. QuTiP (Quantum Toolbox in Python) is an open‑source library that has become an important part of academic research as well as industry. It is widely used for modeling open quantum systems, simulating quantum circuits, studying stochastic effects and testing quantum algorithms. In this tutorial we will explore specific features of QuTiP by calculating the dynamics of closed and open quantum systems, and simulating a quantum circuit.
Machine Learning practitioners often face a trade-off: high accuracy with complex, black-box models (like XGBoost or Random Forests) or lower accuracy with transparent models (like decision trees or linear models). What if you didn't have to choose?
This 90-minute tutorial introduces TRUST (Transparent, Robust, and Ultra-Sparse Trees), a new interpretable regression framework that combines decision trees with sparse linear models to deliver Random Forest accuracy. The algorithm is implemented in the Python package trust-free (available via pip install). We will demonstrate how TRUST autonomously recovers the WHO obesity threshold (BMI = 30) from raw data to inform medical risk pricing.
By the end, you will be able to train high-performing, interpretable regression models and generate automated, natural-language explanation reports for individual predictions and deterministic feature importance.
Want to unlock a powerful new tool?
Differentiable programming is a rising technique in numerical optimization, brought about by the deep learning revolution, providing general and accessible optimization capabilities that can be applied to diverse domains.
The tutorial will give you the basic understanding and tools you need to apply differentiable programming, and have you practice with illustrative problems.
Does your code feel too slow? Do you want to speed it up, but don’t know where to start?
This tutorial introduces attendees to the fundamentals of profiling in Python—why, what, when and how to profile. We start by using Python’s built-in cProfile module to figure out which parts of the code take up most of the runtime, then introduce a third-party module to visualise profiling results and get an overview over the function call hierarchy. In the second half, we use a line-level profiler to precisely pinpoint even a less obvious performance issue, before closing with an outlook on new profiling features coming in Python 3.15 this autumn.
Throughout the tutorial, we include interactive exercises that build on each other. Attendees will get hands-on experience using these tools to systematically investigate performance issues in a Python code base.
The intuitions you build fine-tuning text models are surprisingly bad guides for other modalities. Training configurations that work well for language will silently degrade an image model. Dataset sizes that feel tiny for text are more than enough for adapting a visual style. And audio, despite seeming like its own world, follows an image pipeline once you transform sound into spectrograms, making what counts as a "token" stranger and more interesting than most people expect. The modalities share a vocabulary (fine-tuning, adapters, checkpoints) but not a playbook, and the gaps between them are where the most useful lessons live.
This talk is a practical, comparative tour of fine-tuning across four modalities: text, images, audio, and video. Rather than focusing on one, we will look at what changes as you move between them, how you prepare different data, which training strategies transfer and which don't, where the gotchas hide, and what model merging can do for you once training is done. All examples use Python and the HuggingFace ecosystem with publicly available models and datasets. Whether you are a practitioner looking to branch out beyond NLP or someone curious about what multi-modal fine-tuning looks like in practice, you will leave with a mental map of the landscape and enough pointers to start exploring on your own.
Large language models (LLMs) have become central to modern scientific computing, yet for most practitioners they remain opaque systems - input goes in, text comes out, and the internal mechanism is a mystery. Mechanistic interpretability (MI) is the emerging discipline of reverse-engineering what specific components of a neural network actually do.
Using Andrej Karpathy's microgpt - a fully self-contained, 200-line, dependency-free GPT implementation in pure Python - as our subject, we systematically dissect what a trained language model has learned. No PyTorch, no specialised ML frameworks: just the familiar tools applied to a genuinely novel problem.
The model is tiny by design: 4,192 parameters, a 27-token vocabulary (a–z + a special token), trained on 32,000 names in roughly one minute on a laptop. This makes it the ideal subject for interpretability work - every attention weight is inspectable, every embedding printable, every head ablatable. The scientific question driving the tutorial is: "What has this model actually learned about the structure of names?"
If you work with scientific data, chances are that visualization is one of your strongest tools and biggest time sinks. Whether you're dealing with images from microscopes or telescopes, complex surface reconstructions, 3D point clouds, or n-dimensional feature embeddings from neural networks, some requirements are always the same: performance, interactivity, and extensibility.
napari is a Python library for the visualization and annotation of scientific data that focuses on addressing these needs, staying cross-field and un-specialized at the core, while providing an easy way to develop powerful specialized plugins.
In this tutorial, we will learn the basics of interacting with napari and its features and how to use napari to effectively navigate n-dimensional data. Armed with this knowledge, we will simulate a typical exploratory approach to developing a new image processing workflow in Python and converting it to an easily shearable napari plugin.
Python excels as a glue language. This tutorial will demonstrate how to harness this strength by combining Fortran-implemented number-crunching (SciPy.odeint), object-oriented dimensional analysis for physical-unit-aware code (Pint), and just-in-time compilation (Numba). The result: a lightning-fast, bug-proof Pythonic codebase for scientific computing.
This workshop introduces the fundamentals of data science using Python, focusing on data manipulation and exploratory analysis with the Pandas and Polars libraries. Participants will learn how to load, inspect, clean, transform, and summarize structured datasets through practical examples in Jupyter notebooks. This tutorial also highlights the similarities and differences between Pandas and Polars, providing insight into when each library is most appropriate.
Your analysis works perfectly on your laptop. Three weeks later, it breaks on the server. Your colleague can’t run your code nor reproduce your results. The client’s environment throws mysterious errors. Sound familiar?
This hands-on workshop teaches you to build reproducible workflows using a practical approach that addresses real challenges teams face when sharing code, collaborating on research, or deploying data pipelines.
You’ll learn to:
- Lock dependencies and manage isolated Python environments
- Version control your code and your data
- Externalize parameters using configuration files
- Containerize your application for consistent deployment
- Apply collaboration practices that scale with your team
Leveraging GPU acceleration is now a common necessity for scaling Python projects. NVIDIA GPUs offer unmatched speed and efficiency for data processing and model training, significantly reducing the time and cost associated with these tasks. GPU acceleration is already baked into many projects, or available via plugins. You can use PyData libraries including pandas, polars and networkx without needing to rewrite your code to get the benefits of GPU acceleration.
However, integrating GPUs into our workflow can be a new challenge where we need to learn about installation, dependency management, and deployment in the Python ecosystem. When writing code, we also need to monitor performance, leverage hardware effectively, and debug when things go wrong
This is where RAPIDS and its tooling ecosystem comes to the rescue. RAPIDS, is a collection of open source software libraries to execute end-to-end data pipelines on NVIDIA GPUs using familiar PyData APIs.
In this tutorial we will cover:
- Answers to questions like: “Where do I get a GPU?”, “How do I run a container on a VM with a GPU?”, “How do I install GPU packages into an existing environment?”, “What if I use uv pip?”, “What about conda? ”as well as follow along examples to get a GPU up and running.
- Troubleshooting and monitoring: Examples of performance analysis, diagnostics, and debugging. Showcasing of diagnostic tools like nvdashboard, nvtop, nsys, pynvml, etc.
Remote Sensing has proved to be an important tool in monitoring our earth's ecosystem. Satellite imaging is a vital part of Remote Sensing. Predominantly, Satellite Imaging of the earth has been done in the optical domain and optical Images serve the majority of purpose for earth monitoring. But, these satellites do not have all-weather acquisition capability and this lacuna is filled by the satellite sensors working in the Microwave domain of the Electromagnetic spectrum. Synthetic Aperture Radar(SAR) is an Imaging Radar that acquires images of a particular area on Earth in the microwave region of electro-magnetic spectrum. This workshop deals with the processing of SAR Images and how these images can be beneficial in a variety of geographical applications.