2.0 -//Pentabarf//Schedule//EN PUBLISH 37RGPY@@pretalx.com -37RGPY Unravelling the mystery of free threading for scientific computing en en 20260720T093000 20260720T100000 003000

Unravelling the mystery of free threading for scientific computing

## Target Audience * Python users in scientific computing (researchers, engineers, data scientists) * Open source package maintainers and contributors considering adopting free threading *Developers interested in Python performance and concurrency ## What Attendees Will Learn * How free-threaded Python (PEP 703) changes concurrency and impacts scientific workloads * Which major packages currently support free-threading and latest updates * Practical tips and best practices for adopting free-threading in projects *Tools and resources to help transition codebases for the new paradigm ## Outline: **1. Introduction: Why Free Threading Matters for Scientific Python (5 min)** * The GIL’s impact on scientific computing and parallel workloads **2. What Is Free-Threaded Python? (5 min)** * Overview of PEP 703 and Python 3.14t * Difference between multi processing and threading **3. How is the ecosystem adapting? (10 min)** * Status update: which packages currently support free-threading (NumPy, SciPy, pandas, etc.) * Early experiences from package developers and the community * Share data on performance gains from transition to free threading * Note to reviewer: this work is ongoing, so will have more detail to include here over the next few months **5. Lessons Learned and Best Practices (10 min)** * Practical tips for users: how to take advantage of free-threading in your code * Share some case studies from OSS projects that have begun adopting FTP, describe technical hurdles faced * Some tools / resources that can help you with the transition PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/37RGPY/ Room 1.38 (Ground Floor, Turing) Thomas Wouters PUBLISH 8DKJ7N@@pretalx.com -8DKJ7N From theory to practice: how Python enabled modern astronomical data analysis en en 20260720T101000 20260720T111000 010000

From theory to practice: how Python enabled modern astronomical data analysis

Invited Keynote talk. The idea is to give an overview of the difficulties involving astronomical data analysis and the need to user friendly, rapid evolving and reliable software to enable this scientific exercise. I expect this talk to help the audience brainstorm why Python has been so successful among astronomers and plan to the future: can this pivotal role be kept in the era of foundation models? do we want it to? what are the lessons to be kept in mind and future challenges we will face in the next decades? PUBLIC CONFIRMED Keynote https://pretalx.com/euroscipy-2026/talk/8DKJ7N/ Room 1.38 (Ground Floor, Turing) Emille Ishida PUBLISH G3SRPL@@pretalx.com -G3SRPL Python Tile Programming for GPUs en en 20260720T113000 20260720T120000 003000

Python Tile Programming for GPUs

Parallel programming can be intimidating, but doesn't need to be! There's a new paradigm for parallel programming that's newcomer-friendly, highly productive, and performant: tile-based programming models. Tile programming divides inputs into local arrays that are processed concurrently by groups of threads. Users write sequential array-centric code, and the framework handles parallelization, synchronization, and data movement behind the scenes. In this example-driven talk, we'll introduce you to tile-based programming in Python. We'll present [cuTile](https://github.com/NVIDIA/cutile-python), NVIDIA's new tile programming stack and [Tile IR](https://github.com/NVIDIA/cuda-tile), the new compiler stack that it is built with. You'll learn all about new features of CUDA Tile that have recently been announced, including multi-GPU communication, interoperability with traditional CUDA SIMT, and support for more diverse kernels like convolutions and stencils. We'll compare and contrast tile-based models with traditional parallel programming models. You'll see examples from a variety of domains, including HPC stencils, a sparse matrix vector (SPMV) and conjugate gradient (CG) solver, and AI models from [TileGym](https://github.com/NVIDIA/TileGym). Tile programming aligns well with SciPy's array-centric ethos and has roots in older HPC libraries, such as [NWChem’s TCE](https://nwchemgit.github.io/TCE.html), [BLIS](https://github.com/flame/blis), and [ATLAS](https://math-atlas.sourceforge.net/). In recent years, many tile-based Python programming models for GPUs have emerged, like [Triton](https://openai.com/index/triton/), [JAX/Pallas](https://docs.jax.dev/en/latest/pallas/index.html), and [Warp](https://nvidia.github.io/warp/modules/tiles.html), aiming to make parallelism more accessible for scientists and increase portability. In this talk, you'll: - Learn the best practices for writing tile-based Python applications for GPUs. - Gain insight into the performance of tile GPU code and how it actually gets executed. - Discover how to reason about and debug tile code in Python applications. - Understand the differences between tile and SIMT programming and when each paradigm should be used. - See how tile programming makes your software portable in light of recent hardware trends. By the end of the session, you'll understand how tile-based GPU programming enables more intuitive, portable, and efficient development of high-performance, data-parallel Python applications for HPC, data science, and machine learning. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/G3SRPL/ Room 1.38 (Ground Floor, Turing) Bryce Adelstein Lelbach PUBLISH JEZYYU@@pretalx.com -JEZYYU Ctrl + Alt + Contribute: Bringing Open Source into the Classroom en en 20260720T121000 20260720T123000 002000

Ctrl + Alt + Contribute: Bringing Open Source into the Classroom

The scientific open source community thrives on shared knowledge and welcoming communities, the very system of values that the annual EuroSciPy conference celebrates. At the same time, educators in computational sciences and engineering seek ways to help students move beyond traditional assignments and into experiential learning. Where experiential is a combination of skill-building, networking, and understanding of how science and software happen in the real world. Open Source Experiences was designed to meet both of these needs. In this talk, we will share how we worked with students and open source community mentors to structure a semester-long course where students made valuable contributions to existing scientific Python projects. Students participated in issue triage, bug fixes, documentation improvements, and feature contributions, guided by project maintainers. Through this format, students gained experience with tooling (version control, CI/CD, code formatting, testing), in community practices (contributing guidelines, communication norms), and long-term project planning (design decisions, roadmap alignment), while participating projects gained valuable contributions and new contributors. Student participation and contributions were assessed with regular progress updates. As instructors, we facilitated discussions to guide the Open Source Experience learning process: working on bugs and issues in an open environment, community expectations, GitHub best practices, etc. **Talk outline:** - Course design and goals: balancing academic learning objectives with community needs, assessment strategies. - Collaboration with maintainers: selecting projects, preparing onboarding documentation, setting expectations, and creating a mentorship model that respects both students’ learning and maintainer time. - Student outcomes: reflections on learning gains around technical skills, professional communication, and confidence engaging in open source ecosystems. - Challenges and lessons learned. We’ll also share examples of student contributions and how they augmented both the ecosystem and the students’ portfolios. Whether you’re an educator thinking about how to bring open source into your curriculum or a project leader looking for ways to engage with academic institutions to widen your project’s contributor pipeline, this talk will give you concrete ideas to adapt. PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/JEZYYU/ Room 1.38 (Ground Floor, Turing) Inessa Pawson Ryan C Cooper Ryan Curtin PUBLISH ZDBNXL@@pretalx.com -ZDBNXL Disentangling Cosmology from Astrophysics with Gaussian Process Emulation and Likelihood-Free Inference en en 20260720T140000 20260720T142000 002000

Disentangling Cosmology from Astrophysics with Gaussian Process Emulation and Likelihood-Free Inference

**Summary:** We present a likelihood-free inference framework, built entirely in Python (PyTorch, Optuna, NumPy/SciPy), that combines Gaussian process emulation with neural networks to jointly infer 28 cosmological and astrophysical parameters from galaxy cluster observations. For the first time, we achieve correlation coefficients above 0.97 for all cosmological parameters and above 0.90 for all astrophysical ones. The work has been published in The Astrophysical Journal (2025). **Detailed Description** **1. Motivation and Scientific Context** Galaxy clusters are the most massive objects in the universe held together by gravity. Their properties are determined by two fundamentally different influences: cosmological parameters governing the large-scale evolution of the universe (such as the total matter density, the expansion rate, and the amplitude of matter fluctuations), and astrophysical processes occurring within them (such as star formation, supernova explosions, and energy injection from supermassive black holes). In observational data, these two sets of effects are deeply entangled. Separating them is critical for two reasons. First, unresolved astrophysical uncertainties are a leading source of systematic error in cosmological measurements, contributing to ongoing discrepancies between different experiments measuring quantities like the expansion rate of the universe. Second, understanding feedback processes in clusters is essential for calibrating future cosmological simulation codes. This challenge is becoming urgent. Telescopes such as eROSITA (X-ray), the Simons Observatory and CMB-S4 (microwave), and Euclid and the Vera Rubin Observatory (optical/infrared) are now delivering multiwavelength cluster observations at unprecedented sensitivity. The complexity of this data demands inference methods that can handle high-dimensional parameter spaces without restrictive assumptions about the form of the likelihood function. **2. Simulation Suite and Gaussian Process Emulation** Our work is built on the CAMELS-zoomGZ simulation suite: 768 hydrodynamic zoom-in simulations of galaxy clusters using the IllustrisTNG galaxy formation model, which is governed by 28 free parameters (5 cosmological, 23 astrophysical controlling star formation, winds, black hole accretion, and AGN feedback). The simulations sample this 28-dimensional space using a Sobol sequence for efficient coverage. Since densely populating a 28-dimensional space with simulations is computationally prohibitive, we use the CARPoolGP emulator. This Gaussian process-based tool exploits correlations between pairs of simulations run with the same initial conditions but at different parameter space locations, combined with active learning to optimally place simulations. This allows CARPoolGP to produce low-variance emulations of averaged cluster profiles at any point in the 28-dimensional space. From each cluster we extract five types of radial profiles: gas density, gas temperature, metallicity, X-ray surface brightness (0.5 to 2 keV), and the Compton-y parameter (thermal pressure along the line of sight). The emulator generates stacked versions of these profiles at arbitrary parameter space locations, producing the large training sets required for neural network training. **3. Neural Network Pipeline** The inference task is a regression problem: given a 1D vector of concatenated stacked profiles (29 to 148 values depending on which profile types are used), predict the posterior mean and standard deviation for each of the 28 parameters. The architecture consists of fully connected blocks (linear layer, LeakyReLU activation, dropout), outputting 56 values: a mean and standard deviation per parameter. The loss function, following Jeffrey and Wandelt (2020), ensures outputs correspond to the first two posterior moments without assuming any posterior shape. This makes the approach entirely likelihood-free. The pipeline is implemented in Python: - **PyTorch** for model definition, training, and GPU-accelerated inference. The architecture is modular, with layers, neurons, and dropout as hyperparameters. - **Optuna** for Bayesian hyperparameter optimization via Tree-Structured Parzen Estimation, running 1,000+ trials per experiment optimizing architecture, learning rate, weight decay, and dropout. - **NumPy/SciPy** for all data preprocessing: profile extraction, concatenation, normalization, noise injection, radial cuts, and Sobol sequence sampling. - **Matplotlib** for all visualizations including radar charts, bar charts, and predicted-vs-true plots. Training uses Adam with batch size 256 for 1,000 epochs with early stopping. Data is split 70/15/15 into training, validation, and test sets. We found that 30,000 parameter space locations with five profile types reach near-saturation in accuracy, with marginal gains beyond that. **4. Key Results** With all five profile types concatenated, the network achieves correlation coefficients of 0.99 for matter density, baryon density, and Hubble constant, 0.97 for the spectral index and amplitude of matter fluctuations, and above 0.90 for all 23 astrophysical parameters. To our knowledge, this is the first time such accuracy has been achieved across the full 28-dimensional parameter space using cluster observables. We attribute this to the fact that each parameter introduces distinct, non-degenerate features in the radial profiles. By varying one parameter at a time, we confirmed that no two parameters produce the same signature across all profile types, which is what allows the network to disentangle 28 simultaneous effects. **5. Robustness Analyses** We conducted four systematic studies to stress-test the results: *Noise sensitivity:* Gaussian noise at 10% to 40% of the bin signal (signal-to-noise ratios from 10 to 2.5). Key parameters such as matter density, Hubble constant, and the IMF slope remain robust even at 40% noise. At a signal-to-noise of 10, typical for current X-ray observations, all parameters retain correlation coefficients above 0.7. *Radial cuts:* Progressively truncating profiles from the outside reveals that the innermost 10% of the virial radius contains the bulk of the constraining information, with only modest performance loss. *Mass dependence:* Extending to clusters from 10^13 to 3 x 10^14 solar masses, cosmological parameters remain well constrained across all masses. Astrophysical parameters show a mild decline at higher masses, consistent with more massive clusters approaching self-similar behavior. *Profiles vs. integrated quantities:* Full radial profiles consistently outperform single integrated values, with the largest gap for temperature profiles. This demonstrates that spatial information within clusters carries significant constraining power lost when collapsing to a single number. **7. Relevance to the EuroSciPy Community** This work demonstrates a complete scientific Python pipeline from simulation-based data generation through Gaussian process emulation to neural network inference and visualization. The methodological core, combining GP emulation for scalable training data with likelihood-free neural network inference over a high-dimensional space, is transferable to any domain where forward simulations are expensive, parameter spaces are large, and likelihoods are intractable. Examples include climate modeling, fluid dynamics, and materials science. The talk will emphasize this transferable methodology alongside the scientific results. PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/ZDBNXL/ Room 1.38 (Ground Floor, Turing) Elena Hernandez-Martinez PUBLISH VXRSM8@@pretalx.com -VXRSM8 Scikit-learn's Metadata Routing API en en 20260720T143000 20260720T150000 003000

Scikit-learn's Metadata Routing API

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. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/VXRSM8/ Room 1.38 (Ground Floor, Turing) Stefanie Senger PUBLISH VPYLDF@@pretalx.com -VPYLDF Profiling Python GPU Code en en 20260720T152000 20260720T154000 002000

Profiling Python GPU Code

Your GPU is fast, so why does your Python code still feel slow? When you accelerate Python with CuPy, Numba, PyTorch, JAX, or custom CUDA extensions, performance problems rarely look like a single slow kernel. They look like death by a thousand cuts: tiny launches, hidden synchronizations, accidental host-device copies, stream serialization, and kernels that are "fine" until you look at memory traffic. The good news is that NVIDIA's developer tools can make these issues obvious, if you know what to capture and how to read it. In this talk, I'll show a practical, Python-first profiling workflow using Nsight Systems, Nsight Compute, and NVTX. We'll start at the top with system-level timelines to answer "where did the time go?" then drill down into kernel-level analysis to answer "why is this kernel slow?" Along the way, you'll learn how to annotate Python code with NVTX so your traces are readable, how to profile from notebooks and CI, and how to turn profiler output into a short, repeatable optimization loop. Key takeaways: - How to use NVTX ranges and markers from Python to make timelines explain themselves. - How to capture the right Nsight Systems trace to spot launch overhead, sync points, copies, and stream issues. - How to pivot from a timeline hotspot to Nsight Compute and choose metrics that actually answer your question. - How to interpret common kernel bottlenecks (memory throughput, occupancy limits, instruction mix) without drowning in counters. - A checklist for avoiding profiling traps (implicit sync, warmup, clock variability, sampling noise, and "profiling changed my code"). - A repeatable workflow you can apply to real Python GPU stacks, from single kernels to end-to-end pipelines. By the end, you'll be able to profile Python GPU code with intent, isolate the bottleneck you actually have, and make changes you can measure and defend. PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/VPYLDF/ Room 1.38 (Ground Floor, Turing) Bryce Adelstein Lelbach PUBLISH 8T33ZK@@pretalx.com -8T33ZK From Code to app, how to ship your tool to your non programming collaborators en en 20260720T160000 20260720T163000 003000

From Code to app, how to ship your tool to your non programming collaborators

The purpose of this talk is to make people aware of options to share their Python code with non-coding collaborators and to share some lessons learned and practical tips. Based on real life examples of bundling applications using PyInstaller and Conda constructor, I will share my experience on how to do that, and what problems you might encounter. These two tools are used as they represent two different approaches: 1) PyInstaller (also Py2exe, etc) - is a tool that takes your python code and creates frozen executable that contains pa Python interpreter and all dependencies. So iIt couldan be downloaded and used directly, even offline 2) Conda constructor - is a tool for building an installer that sets up a full Conda environment, adds shortcuts, etc. At a cost of higher complexity, the application can self-update and it is more flexible in terms of what it can do. The presentation will include simple examples of how to use these tools, and also some tips on how to automate the process using CI. There will also be a part about problems that you might encounter, like signing of executables and why it might be important. Armed with these examples and top tips, I hope you will gain some key insights into how to make your Python code easier to use, and reuse, for collaborators from all walks of life!" PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/8T33ZK/ Room 1.38 (Ground Floor, Turing) Grzegorz Bokota PUBLISH PXGC9R@@pretalx.com -PXGC9R Parallel Reactive Groundwater Transport Modeling en en 20260720T093000 20260720T100000 003000

Parallel Reactive Groundwater Transport Modeling

Contaminated groundwater often carries multiple dissolved chemical species that can react with each other. These reactions may cause mineral precipitation — the formation of solid phases from dissolved substances — which can reduce the hydraulic conductivity (the ease with which water flows through) of the subsurface. Interactions with the solid matrix of the aquifer material, such as cation exchange — where positively charged ions in solution swap with ions bound to mineral surfaces — can further alter dissolved species concentrations. Numerical modeling of these processes encompasses three groups: (1) groundwater flow, (2) multi-species solute transport, and (3) geochemical transformations of the transported species. One approach to simultaneously simulate all three process groups is to couple a flow and transport model with a hydrogeochemical model. In the approach presented here, MODFLOW 6 handles the simulation of groundwater flow and solute transport, while PHREEQC 3 computes the geochemical reactions. MODFLOW 6 is the current version of the MODFLOW framework, a widely used open-source groundwater modeling system. It can simulate groundwater flow (GWF), solute transport (GWT), energy transport (GWE), and particle tracking (PRT). PHREEQC is a well-established geochemical modeling tool for computing equilibrium and kinetic reactions in aqueous solutions. Coupling the two models requires runtime data exchange so that concentrations in all model cells can be updated according to the computed chemical reactions at each exchange time step. The data exchange on the MODFLOW 6 side is handled by pymf6, an open-source Python library that provides a high-level interface for stepping through a simulation at runtime. It can inspect and modify MODFLOW 6 variables during execution. On the PHREEQC side, data exchange is managed by PhreeqPy, which uses PhreeqcRM — a PHREEQC variant specifically designed for coupling with transport models. PhreeqcRM exposes a comprehensive API that enables programmatic control over all geochemical modeling capabilities. The newly developed reactive transport model rtmf6, presented here, is built on pymf6 and PhreeqPy. Since computation times can be substantial for large models, a key design requirement was to parallelize as many computational steps as possible. Two parallelization strategies are implemented: flow and transport modeling runs as parallel processes, while the geochemical computations in PhreeqcRM use multi-threading. Starting from a base MODFLOW 6 model, pymf6 generates a separate input dataset for each transported species. Each component model contains only the species-specific parameters that differ from the base model and references the base model's input data to avoid duplication. Depending on the application, this typically yields 10 to 30 component models, or more for complex geochemical scenarios. Each component model runs in its own process. Because the transport of each species is independent within a given time step, all component models can execute in parallel. When at least one CPU core is available per component model, this yields highly parallel execution of the flow and transport computations. The optimal number of threads for PhreeqcRM depends on the available CPU cores and the number of model cells. Large models can therefore potentially utilize many cores to accelerate the geochemical computations. Performance benchmarks for this aspect are currently in progress. Benchmark results from rtmf6 show good agreement with simulations from PHT3D, an established reactive groundwater transport model. Because rtmf6 leverages the full capabilities of MODFLOW 6, it can address a substantially broader range of applications than PHT3D. Comparative performance benchmarks against PHT3D are currently in progress. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/PXGC9R/ Room 1.19 (Ground Floor, Shannon) Mike Müller PUBLISH EALXXJ@@pretalx.com -EALXXJ (Re)-connecting foundational libraries with their communities: Successes, failures, and surprises in building the napari plugin sustainability initiative en en 20260720T113000 20260720T120000 003000

(Re)-connecting foundational libraries with their communities: Successes, failures, and surprises in building the napari plugin sustainability initiative

Many scientific Python projects follow a familiar arc: early excitement, rapid adoption, a burst of community-built extensions—and then a slow drift apart. The technical debt is felt by maintainers, but the *community* debt is seen through the erosion of trust, languishing communication, and loss of shared purpose. This talk is for anyone maintaining a Python project with a broader community, developing downstream tools, or interested in practical approaches to open-source sustainability. In late 2025, with support from a [URSSI Early Career Fellowship](https://urssi.us/), [napari](https://napari.org/) launched the plugin sustainability initiative to rekindle the relationship between the core napari project and its downstream plugin community. The initiative started a [working group](https://napari.org/stable/community/meeting_schedule.html) of core contributors, plugin developers, and users—novice to experienced—across roles, time zones, and disciplines. This talk will share what worked: engaging the global community, oppenness to community creativity, and creating space for domain scientists to share real workflows and frustrations. It will also share real challenges: reaching folks who had already disengaged, diversifying the group over time, and including voices that don't have bandwidth for regular meetings. The most impactful finding has been how much the community *wants* to shape solutions once given the opportunity, where previously folks found themselves feeling as observers on the outside. The conversation was never "what should the core team do for us?" but "how can we work on this together?" This shift—from a service relationship to shared ownership—has been the single most valuable outcome. It requires no tooling, but does require deliberate effort to maintain. The biggest barriers remain social: not knowing whether contributions were welcome, not knowing who else was working on similar problems, and not having a channel that felt heard. The working group has converged on [three interconnected efforts](https://napari.org/island-dispatch/blog/plugin-sustainability-initiative.html) shaped directly by the community's priorities. **1. A combined automated and human review system** emerged as the highest-impact focus. We're building automated tooling—inspired by [SciPy's repo-review](https://repo-review.readthedocs.io/en/latest/)—that checks plugin repositories for packaging quality, test coverage, dependency health, and CI configuration. Compatibility checks via [npe2api](https://github.com/napari/npe2api) detect when plugins break against new napari releases and surface that to developers *before* users hit the problem. Alongside automation, human peer review modeled on [PyOpenSci](https://www.pyopensci.org/about-peer-review/) pairs experienced community members with plugin developers for domain-aware feedback, with a potential [JOSS](https://joss.theoj.org/) partnership for a publication pathway. **2. Modernized packaging and development infrastructure.** We're updating the [napari-plugin-template](https://github.com/napari/napari-plugin-template) and [plugin documentation](https://napari.org/stable/plugins/index.html) based on firsthand accounts from working group members who upgraded their own plugins, with a focus on creating beginner-friendly and advanced tracks. This includes guidance on reproducible environments with [pixi](https://pixi.sh/) and [uv](https://docs.astral.sh/uv/), clearer separation of computation from UI code, and real-world-tested upgrade paths. We're exploring curated plugin bundles—tested combinations that install together cleanly—to directly address the dependency hell that drives users away. **3. Discoverability and stewardship programs.** We're working to surface maintenance status, compatibility, and quality signals on the [napari hub](https://napari-hub.org/) as well as improving searchability for scientist-first experiences. A plugin donation program would let maintainers hand off plugins to new community stewards rather than letting them as abandonware. We're exploring a shared GitHub organization for collectively maintaining plugins that is separate from the core napari organization, so that the plugin community can share ownership. These efforts are works in progress, and open questions remain about sustaining the community's energy, but this talk will share how we plan to sustain the intiative going forward even beyond the life of the working group. So far, we have found bi-directional impact where downstream developers have improved experiences, tooling, and documentation and we also see an investment from downstream developers back into various parts of the core napari project. Everything being built is open source and documented for other communities to adapt. Ultimately, investing in listening and shared ownership *while* building technical infrastructure is what engages a broad community, and builds trust that spending time in the ecosystem is worthwhile. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/EALXXJ/ Room 1.19 (Ground Floor, Shannon) Tim Monko PUBLISH PRCPUX@@pretalx.com -PRCPUX Building a Scientific Taxonomy at Scale with Graph Clustering, Embeddings, and LLMs en en 20260720T121000 20260720T123000 002000

Building a Scientific Taxonomy at Scale with Graph Clustering, Embeddings, and LLMs

## The Problem Large-scale publication databases rely on author-provided keywords that are noisy, inconsistent, and semantically ambiguous. Variants such as "machine learning," "ML," and "machine-learning" refer to the same concept, while other terms are overloaded or context-dependent. Manual curation does not scale, and simple string matching or rule-based normalization fails to capture semantic structure. To support reliable trend analysis, search, and analytics, organizations need a consistent, hierarchical scientific taxonomy built at scale. This talk presents a production system that transforms hundreds of thousands of raw keywords into a structured, semantically grounded taxonomy with over **110,000 concepts**. ## Building a 5-Level Scientific Taxonomy We extend OpenAlex's existing **4-level hierarchy** (Domain → Field → Subfield → Topic) with a fifth **Concept layer**, creating a complete **5-level taxonomy** suitable for fine-grained analysis. Raw keywords are normalized into candidate concepts and embedded using **SPECTER2** to capture domain-specific semantic relationships. To group related concepts, we construct a similarity graph over embeddings and apply the **Leiden community detection algorithm** using **igraph**, scaling to over **100K nodes** while maintaining strong modularity and interpretability. The resulting clusters form the backbone of the concept layer. ## Strategic Multi-Stage LLM Integration A key design challenge was deciding when to rely on deterministic methods and when LLMs add unique value. Rather than using LLMs end-to-end, we integrate them at **five targeted stages** where semantic judgment is critical: 1. **Granularity Filtering** – Filtering candidate concepts to the appropriate Concept-level granularity, excluding terms that are too broad or too specific. 2. **Field Classification** – Assigning concepts to one of **26 OpenAlex fields** in cases where embedding similarity alone is ambiguous. 3. **Semantic Cluster Renaming** – Generating interpretable, human-readable labels for concept clusters. 4. **Explanation Generation** – Producing concise semantic descriptions for each concept to support downstream validation and analytics. 5. **Topic Assignment Validation** – Validating hierarchical attachment to Level-4 topics using a combination of multi-embedding similarity and LLM-based classification, with support for multi-label assignments. This hybrid approach preserves scalability and reproducibility while leveraging LLMs for nuanced semantic decisions that deterministic methods struggle with. ## Technical Infrastructure * **SPECTER2 embeddings** provide domain-aware semantic representations trained on scientific citation networks. * **Leiden clustering (igraph)** enables scalable community detection over large similarity graphs. * **Qdrant** supports efficient vector search for hierarchical attachment and large-scale similarity queries. * **Azure OpenAI** is used for structured LLM inference with prompt patterns designed for consistency and cost control. * A **validation framework** combines human review, automated consistency checks, and AI-assisted quality control before concepts are finalized. ## Production Impact The resulting taxonomy is deployed in production to automatically tag **millions of publications**. It powers real-time academic trend detection, cross-journal portfolio analytics, and strategic decision support for research planning and resource allocation. ## Key Takeaways Attendees will learn: * How to decide where LLMs add value in large-scale NLP pipelines * How to scale graph clustering to **100K+ nodes** in Python * Practical trade-offs between embeddings, graph methods, and LLMs * How to design hybrid embedding–LLM architectures that balance cost, accuracy, and scalability * Validation strategies for correctness-sensitive semantic systems in production PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/PRCPUX/ Room 1.19 (Ground Floor, Shannon) Daniele Raimondi PUBLISH QNGLCM@@pretalx.com -QNGLCM `LinearOperator`: stories from advancing an 18 year old data structure in SciPy en en 20260720T140000 20260720T142000 002000

`LinearOperator`: stories from advancing an 18 year old data structure in SciPy

[`scipy.sparse.linalg.LinearOperator`](https://scipy.github.io/devdocs/reference/generated/scipy.sparse.linalg.LinearOperator.html) is the data structure which underlies the iterative sparse linear solvers (like conjugate-gradient) in SciPy, as well as matrix factorisation problem algorithms like `svds` and `eigs`. I recently undertook a master's project in adding support for batched input and alternative array types to the iterative sparse linear solvers in SciPy, and the first step was to enhance the `LinearOperator` data structure. This turned out to be a lot more challenging than first anticipated! The code that has existed for so long had not only retained idiosyncrasies from when it was first implemented, but had also accumulated some inconsistencies over time. The challenge was to figure out how to add the features I needed while avoiding breaking functionality for existing users. I'll discuss the successes of squaring up the `LinearOperator` interface with modern initiatives like [the array API standard](https://data-apis.org/array-api/draft/API_specification/index.html), as well as how I've made us of this new interface in the iterative sparse linear solvers. I'll also mention some of the research results from my investigation into bringing batched sparse linear solvers to Python. No prior experience is expected for this talk. You can expect to come away from this talk better equipped to make changes to established data structures that are widely used across the world of scientific Python, and with a greater understanding of what it takes to implement support for modern paradigms of performant scientific Python code. PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/QNGLCM/ Room 1.19 (Ground Floor, Shannon) Lucas Colley PUBLISH UZQ3S3@@pretalx.com -UZQ3S3 Using Python for satellite operations: Lessons from the Mauve Space Mission en en 20260720T143000 20260720T150000 003000

Using Python for satellite operations: Lessons from the Mauve Space Mission

Mauve is a 16U smallsat in a ~500km Sun-synchronous orbit, studying stars. To point it in the right direction its Attitude Determination and Control System (ADCS) uses a combination of star trackers and a gyro. However, due to slight misalignments between the star trackers and the telescope boresight the target can drift out of the telescope’s view. To help overcome this Mauve uses a Payload-in-the-loop (PITL) system. Mauve can use the data from its detector to help identify when this drift is occurring and act to counter it. This PITL system is running in Python. During this talk I will explain the physical conditions that Mauve experiences and how these create a challenge for the software to handle the drift. A proof-of-concept simulator was a crucial part of the development lifecycle of Mauve’s onboard software. I will demonstrate the benefits of careful iteration in building confidence in PITL as a potential solution. I will explore some of the challenges encountered during development of the flight software, looking at development in a restricted environment and limited opportunities to test on flight hardware. The talk will also reflect on the interdisciplinary nature of developing flight-ready software, and how combining physical insight with software engineering experience proved vital to addressing on-orbit behaviour. Overall this talk will show that while Python may not be the best language to solve a particular problem, it can be the correct language for tackling a real-world engineering problem. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/UZQ3S3/ Room 1.19 (Ground Floor, Shannon) Lawrence Bradley PUBLISH KFBJXK@@pretalx.com -KFBJXK Finding the Right ROR: Semantic Search for Research Institutions en en 20260720T152000 20260720T155000 003000

Finding the Right ROR: Semantic Search for Research Institutions

Research affiliation strings are messy in the real world. The same institution might appear as an acronym, a translated name, an outdated label, or a partially written reference. If you’ve ever tried to map these freeform inputs to persistent identifiers like ROR, you know that simple string matching quickly falls apart. In this talk, we’ll look at institution matching from a different angle: treating it as a semantic retrieval problem instead of a normalization problem. I’ll walk through a practical pipeline that uses named entity recognition to extract institutions, embeddings to represent them semantically, and vector search to retrieve the best ROR candidate. The goal isn’t just better accuracy, but to build a system that is maintainable as new institutions appear and naming conventions evolve. This session focuses on real implementation experience, not just models. We’ll cover architecture decisions, evaluation strategies, common failure cases, and trade-offs between rule-based and embedding-based approaches. You’ll see what worked, what didn’t, and what we learned from running this in production. If you’re working on entity resolution, search systems, metadata pipelines, or NLP in production, this talk will give you practical ideas you can reuse. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/KFBJXK/ Room 1.19 (Ground Floor, Shannon) Diogo Rodrigues PUBLISH CQHPYG@@pretalx.com -CQHPYG Rust for High Performance Computing (HPC) in Python en en 20260720T160000 20260720T163000 003000

Rust for High Performance Computing (HPC) in Python

In this talk, we will review the current state of Python in HPC, examine the role of key libraries like NumPy and Dask, and see how to use PyO3 to create robust Rust bindings for Python in a way that simplifies the process of building and distributing packages. We’ll explore how Rust brings specific advantages to HPC, including guaranteed memory safety without garbage collection, zero-cost abstractions, and true parallelism. Attendees will leave with a clear understanding of the 'why' and 'how' of leveraging Rust in their Python-based HPC workflows, positioning them to develop faster, safer, and more scalable computational code. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/CQHPYG/ Room 1.19 (Ground Floor, Shannon) Cheuk Ting Ho PUBLISH TENZMQ@@pretalx.com -TENZMQ Engineering Fortran-to-Python Bindings in C++ with nanobind[_json] and cibuildwheel en en 20260720T140000 20260720T142000 002000

Engineering Fortran-to-Python Bindings in C++ with nanobind[_json] and cibuildwheel

## Detailed plan of the talk: ### Intro - A short-summary of the **PartMC** package. - Outlining the requirements for a usable and maintainable Python interface - Quick overview of the project architecture in regards to the binding and packaging process ### Challenges solved - Multi-platform packaging process with **cibuildwheel**, including Fortran dependencies (some errors included too long filenames on Windows, some of the dependencies were never compiled on Windows earlier!) - Codecov coverage for a 4-language codebase - Garbage collection of Fortran objects - Static linkage of **10+** git submodules, including some CMake trickery with undocumented CMake features! - Exposing C++ interface to Python through **nanobind**, including writing custom type casters - Internal JSON usage, which resulted in adopting an unmaintained **nanobind_json** codebase ### Remaining challenges - Exception handling/propagation from C++ to C++ across Fortran layer (works only on selected platforms) - Eliminating (and type-checking) boilerplate glue code (Fortran+C), while retaining codecov functionality - The project is open-source! Contributions are welcome! ### Highlights and benefits - Reducing entry threshold for users from days (cumbersome installation of dependencies, multi-language compilation, needed knowledge of Bash, Fortran & Python to complete a simulation) to seconds (single-click exec of example **Jupyter Notebooks** on **Colab**) - Coupling with other Python-implemented simulation components (e.g. packages simulating light scattering on particle populations) - Usage of PartMC via PyPartMC as a test-time dependency for other packages - Enabling access to PartMC from **Julia** and **Matlab** via respective Python bridges PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/TENZMQ/ Room 2.41 (First Floor, Turing) Gracjan Adamus PUBLISH BJLLHM@@pretalx.com -BJLLHM USB-C Moment for AI: Building MCP Servers with FastMCP and Python en en 20260720T143000 20260720T150000 003000

USB-C Moment for AI: Building MCP Servers with FastMCP and Python

Before USB-C, every device needed its own cable. Before MCP, every AI needed its own integration. You can build a server in 20 lines of Python. 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. What You'll Learn: - Hook & ContextThe cable chaos analogy. Why AI tool integration is broken today and what MCP fixes. - MCP in 4 MinutesProtocol anatomy: tools, resources, prompts. How the client–server model works. Why Anthropic open-sourced it and who adopted it. - Live Build: Your First FastMCP ServerBlank file → working server in 20 lines. Decorators, type hints, auto-discovery. Connecting to Claude Desktop live on stage. - From Local to ProductionPackaging and deploying your server. Transport options: stdio vs. HTTP/SSE. Connecting to Claude Code in a real dev workflow. - Security & Anti-PatternsOAuth 2.1 authentication. Sandboxing and permission scoping. TLS configuration. The three anti-patterns that get MCP servers hacked. - Ecosystem & What's NextMCP registry, community servers, roadmap. Where Python fits in the broader MCP landscape. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/BJLLHM/ Room 2.41 (First Floor, Turing) Ruslan Korniichuk PUBLISH JUEQLF@@pretalx.com -JUEQLF Pure functions + Separate I/O: Functional Python Pipelines for Reproducible Experiments en en 20260720T152000 20260720T155000 003000

Pure functions + Separate I/O: Functional Python Pipelines for Reproducible Experiments

Scaling data science pipelines in research and industry poses well-known maintainability challenges. Research codebases must support rapid iterations as new insights and ideas emerge. Industry projects, meanwhile, need to scale amid ever-changing business needs and organizational complexity. Effective data science 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. We discuss how data science projects can benefit from established design patterns in software engineering, specifically from functional programming. We demonstrate how composition, side-effect isolation and separation of concerns can be embedded into projects from their outset, without adding heavy framework complexity. Guided by real-world use cases we argue that by adopting these principles early, projects can significantly improve reproducibility, testability, and refactorability. Our analysis builds on [Ordeq](https://github.com/ing-bank/ordeq), an open-source Python library for building maintainable data pipelines actively used by data scientists, analysts, and engineers at ING. This framework was designed to bridge the gap between exploratory research and production systems, without forcing data scientists to abandon familiar workflows. It is currently used in production applications, as well as during exploratory research and experiments. In this talk we will not go in-depth into the framework - which we did at PyData Amsterdam 2025. If you're interested in learning more, the you can have a look at the [code](https://github.com/ing-bank/ordeq) and [documentation](https://ing-bank.github.io/ordeq/). Attendees will leave with practical design principles for structuring data projects that scale naturally, from prototype to production, regardless of whether they adopt Ordeq itself. - Ordeq GitHub: https://github.com/ing-bank/ordeq - Ordeq documentation: https://ing-bank.github.io/ordeq/ PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/JUEQLF/ Room 2.41 (First Floor, Turing) Niels Neerhoff Simon Brugman PUBLISH SLDHUM@@pretalx.com -SLDHUM Towards Pythonic custom constraining in FreeCAD 2D drawing en en 20260720T160000 20260720T163000 003000

Towards Pythonic custom constraining in FreeCAD 2D drawing

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. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/SLDHUM/ Room 2.41 (First Floor, Turing) Ajinkya P Dahale PUBLISH MLEJZS@@pretalx.com -MLEJZS How to use skrub Data Ops in practice en en 20260721T093000 20260721T100000 003000

How to use skrub Data Ops in practice

Building a machine learning pipeline is rarely a straightforward effort: data can be spread across multiple sources and storage formats; data preparation can involve multiple complex steps, unclear choices and assembling data coming from different sources; all operations must be executed while avoiding data leakage; there may be hyper-parameters to tune; and at the end of the process, it should be possible to re-execute all the same operations with the same parameters on unseen data. Skrub Data Ops are a pipeline-building framework that alleviates these criticalities: Data Ops wrap around any arbitrary function provided by the user, including non-standard data fetching and preparation steps; they simplify combining tables by letting users adopt the dataframe library of their choosing; they keep track of samples throughout the pipeline construction and training to avoid data leakage; they simplify the construction of rich hyper-parameter search spaces thanks to a set of "choose from" functions that allows setting arbitrary operations as choices. Finally, Data Ops build a directed acyclic graph that tracks all the operations and estimators fitted up until a given point: this allows to retain the state of fitted estimators, and re-execute all the steps in the same way on unseen data. Through the presentation, we will show how these features can be employed in practical scenarios. We start from a traditional machine learning pipeline built using the skrub Data Ops and employ Optuna as the backend for performing hyper-parameter search. We then move on to a multi-table scenario where tables are stored in a relational database: thanks to their support for arbitrary user code, it is not necessary to convert data to a dataframe format until training. We conclude the talk by presenting an example of image classification with Pytorch and skorch: Data Ops are not limited to tabular data and can handle other typical machine-learning tasks, while simplifying the code necessary to generate and test different model architectures. All material for the talk will be made available online. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/MLEJZS/ Room 1.38 (Ground Floor, Turing) Guillaume Lemaitre Jérôme Dockès PUBLISH C7BCMN@@pretalx.com -C7BCMN What Is Your Simulation Doing Right Now? en en 20260721T101000 20260721T111000 010000

What Is Your Simulation Doing Right Now?

Scientific workloads are the worst case for Python observability: they run for days, they can't be restarted, they're thread-heavy, most of their time is spent inside compiled extensions, and more of them run on GPUs every year. For most of Python's life, the tooling answer to "what is my process doing?" was: restart it with instrumentation and hope the problem reproduces. Between 2024 and 2026, that changed. This keynote is a guided tour of the new reality, live on stage, plus an honest map of what's still missing -- and a plan. ### Act I: Observe without restarts. Python 3.14 shipped PEP 768, a safe external debugger interface that ended a decade of tools force-injecting code into running interpreters via GDB. Its first consumer is in everyone's hands already: `python -m pdb -p PID`. Python 3.15 builds on the same machinery with Tachyon (PEP 799), a statistical sampling profiler in the standard library: attach to a live process by PID without pausing it, sample at up to 1 MHz, and view wall-clock, CPU, or GIL-contention profiles as flame graphs, live terminal dashboards, or line-level heatmaps. I'll attach to a hung "simulation" and find the problem without restarting it -- including answering the question every multithreaded NumPy user has asked: which thread is starving the others? ### Act II: The three hard places. Where the new tools still go dark, demonstrated rather than hand-waved: * native code: your NumPy kernel is currently one opaque frame, * free-threaded builds where the standard library leads and popular ecosystem tools still lag, and * GPUs where excellent vendor timelines exist but nothing speaks Python natively and no common trace format connects them. ### Act III: The near future. Python 3.16 is in its alpha phase right now, so let's dream big: real native stack unwinding in the standard profiler, a stable introspection contract for external tools, contention metrics designed for the free-threaded world, a vendor-neutral bridge between Python stacks and GPU timelines... wouldn't that be something? Some of those things CPython cannot do alone, because they live in the build systems and wheels the scientific community maintains. You'll leave with tools you can use on your cluster the week you get home, a clear-eyed picture of their limits, and a reason to contribute to Python 3.16's development. It's the perfect time. No prior profiling experience required. Everything shown works from the command line on stock CPython: 3.14 features are in stable releases today, and 3.15 features are demonstrated on the betas of the release shipping this October. PUBLIC CONFIRMED Keynote https://pretalx.com/euroscipy-2026/talk/C7BCMN/ Room 1.38 (Ground Floor, Turing) Łukasz Langa PUBLISH YTW8PA@@pretalx.com -YTW8PA The road(map) towards SciPy 2.0 en en 20260721T113000 20260721T120000 003000

The road(map) towards SciPy 2.0

In the first part of the talk, I will briefly discuss new features added to SciPy over the last year of development. Highlights include Array API interoperability, making SciPy use harware accelerators, improvements to large-scale linear algebra and more. In the second part of the talk, I will discuss technical improvements planned by the SciPy team, and the roadmap for the SciPy evolution, again focusing on technical side of things: enhancements to SciPy's coverage, performance and scalability, porting SciPy provided algorithms to novel hardware and software systems. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/YTW8PA/ Room 1.38 (Ground Floor, Turing) Evgeni Burovski PUBLISH 9QDAAZ@@pretalx.com -9QDAAZ splinebox: pure-python toolkit for splines en en 20260721T121000 20260721T123000 002000

splinebox: pure-python toolkit for splines

[splinebox](https://splinebox.readthedocs.io/en/stable/) is born from a collaboration between V. Uhlmann (Professor in Bioimaging and Data Analysis, University of Zurich) ans the EPFL Center for Imaging. Rather than using splines to interpolate existing data (the main concept driving the decisions behind `scipy.interpolate`'s implementation), we use splines to represent data, and need to be able to update them iteratively in the context of active contours for example. The implementation of exponential basis functions allows the perfect description of circles and ellipses (with closed splines) which has been useful for the 3D modelling of coronary arteries. The implementation of `splinebox` in python+numba makes it easy to extend and read. Please check out our [examples gallery](https://splinebox.readthedocs.io/en/stable/auto_examples/index.html) for inspiration. Our talk will describe the software decisions behind the project and illustrate its use. PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/9QDAAZ/ Room 1.38 (Ground Floor, Turing) Florian Aymanns PUBLISH CLUCAW@@pretalx.com -CLUCAW PyData/Sparse & Finch: extending sparse computing in the Python ecosystem en en 20260721T140000 20260721T143000 003000

PyData/Sparse & Finch: extending sparse computing in the Python ecosystem

In this talk we're going to understand the current landscape of sparse computing in the Python ecosystem first. Then a high-level overview of the Finch technology and compiler's architecture will be presented together with other solutions vital for the project: Array API Standard and binsparse format. Next, we're going to present a selected set of benchmarks - also focusing on real world use-cases: how Finch impacts users' experience when writing sparse programs in Python. Last but not least a showcase of the current development will be shown - pure Python rewrite of Finch compiler. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/CLUCAW/ Room 1.38 (Ground Floor, Turing) Mateusz Sokół PUBLISH YFK3YB@@pretalx.com -YFK3YB Pixi: better developer experience for scientific Python projects en en 20260721T144000 20260721T151000 003000

Pixi: better developer experience for scientific Python projects

[Pixi](https://pixi.prefix.dev/latest/) is to [conda](https://docs.conda.io/projects/conda/en/latest/index.html) as [uv](https://docs.astral.sh/uv/) is to [pip](https://pip.pypa.io/en/stable/): a modern package management tool, offering a workspace-based developer experience. Like conda, Pixi supports many platforms and programming languages, so is perfect for developers working in languages beyond Python. Many scientific Python packages like SciPy and XArray have started using Pixi to enable better developer experiences. 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. You can also expect a quick live demo of some of the cool things made possible by Pixi :) No prior knowledge is expected! PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/YFK3YB/ Room 1.38 (Ground Floor, Turing) Lucas Colley Wolf Vollprecht PUBLISH G7BJFJ@@pretalx.com -G7BJFJ Automating Scientific Paper Classification at Scale with Retrieval–Reranking and LLMs en en 20260721T152000 20260721T154000 002000

Automating Scientific Paper Classification at Scale with Retrieval–Reranking and LLMs

## The Problem Scientific papers are typically tagged with author-provided keywords that are inconsistent, ambiguous, and poorly aligned with standardized taxonomies. Variants such as "machine learning," "ML," and "machine-learning" refer to the same concept, while other terms are overloaded or context-dependent. Manual curation does not scale, and naive string matching fails to capture semantic meaning. This talk focuses on the paper classification problem: given a large, fixed taxonomy, how can we automatically and reliably tag papers at scale? ## The Foundation: A Large-Scale Concept Taxonomy The classification pipeline assumes a **110K+ concept scientific taxonomy** that extends OpenAlex's **4-level hierarchy** with a granular concept layer. This structured taxonomy provides the semantic backbone that makes large-scale, consistent paper tagging possible. (Taxonomy construction is treated as given context; the focus of this talk is on classification and deployment.) ## Stage 1: Candidate Retrieval with Bi-Encoders **Input Processing** We extract paper metadata (title, abstract, author keywords) and generate **SPECTER2 embeddings**, a bi-encoder model trained on scientific text that supports efficient pre-computation and caching. **Vector Search** Using **Qdrant**, we retrieve the top-N candidate concepts (typically N = 50–100) via cosine similarity. This step reduces the search space from over **110,000 concepts** to a manageable candidate set while maintaining high recall. **Threshold Tuning** We discuss similarity threshold strategies that balance recall (avoiding missed relevant concepts) and precision (limiting noise passed to later stages). ## Stage 2: Reranking with Cross-Encoders and LLMs **Why Cross-Encoders?** Bi-encoders scale well but miss fine-grained interactions between paper content and concept descriptions. Cross-encoders jointly encode paper–concept pairs, capturing nuanced semantic relationships at higher computational cost. **Reranking Architecture** Cross-encoder models score each candidate pair, producing a high-precision ranking over Stage-1 results. **LLM-Based Filtering** For ambiguous cases, we integrate **Azure OpenAI** for context-aware validation. LLMs help detect non-core mentions (e.g., negative references or future work) and resolve borderline assignments. **Final Assignment** The system outputs ranked, **multi-label concept assignments** with calibrated confidence scores, selecting top-k concepts per paper based on learned thresholds. ## Production Deployment and Impact The pipeline is deployed on **millions of papers**, standardizing noisy author keywords and enriching metadata with semantically consistent concept tags. This enables: * Real-time trend detection (identifying emerging topics weeks early) * Cross-journal portfolio analytics * Data-driven strategic decision-making We also discuss operational challenges, including batch processing, GPU utilization, cost–accuracy trade-offs for cross-encoders, evaluation metrics (**Precision@k, NDCG**), and production monitoring. ## Key Takeaways Attendees will learn: * Retrieval–reranking design patterns for large label spaces * When to use **bi-encoders vs. cross-encoders** in production * Practical **Qdrant optimization** for large-scale vector search * Cross-encoder deployment and cost trade-offs * Selective LLM integration for context-aware filtering * Thresholding and confidence calibration for **multi-label classification** * Batch processing and GPU optimization strategies * How structured taxonomies improve classification accuracy at scale ## Audience Data scientists, ML engineers, and NLP practitioners working on document classification, retrieval systems, or production NLP pipelines. Familiarity with embeddings, transformers, and vector databases is expected. PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/G7BJFJ/ Room 1.38 (Ground Floor, Turing) Daniele Raimondi PUBLISH U9TNWY@@pretalx.com -U9TNWY Optimize the geospatial data processing with Apache Sedona and SedonaDB. en en 20260721T160000 20260721T162000 002000

Optimize the geospatial data processing with Apache Sedona and SedonaDB.

The Apache Sedona ecosystem is powerful, but using it with an invalid understanding might lead to wasting computational cycles, data skew, or even application crashes. This talk aims to discuss in detail how popular spatial processing algorithms work and how we can make them more efficient. The talk focuses on the typical problems a Spatial Data Engineer, Analyst, or Scientist faces daily, such as spatial joins, KNN searches, or integrating different spatial tooling together. The talk consists of four major sections, - Introducing the Apache Sedona ecosystem and how Apache Sedona solves complex distributed spatial problems, like spatial partitioning and spatial joins - Explaining what Spatial Parquet and Geoparquet are and the problems they solve - Optimizing spatial processing pipelines, including - reducing skew in spatial join - evenly distributed spatial partitioning - k nearest neighbor search - effiecient user defined functions with Arrow optimization - efficient storing and retrieving data from spatial Parquet - powerful indexing techniques - understanding of limitation of the Apache Sedona Python API - When to use Apache SedonaDB in your spatial data processing tasks. To create robust spatial queries, it's important to understand the fundamentals and how Apache Sedona implements specific spatial algorithms. This will help you select the right tools for the job and improve user satisfaction with Apache Sedona. SedonaDB is a rapidly growing, single-node open-source analytical database built around spatial data. It is written in Rust, leveraging DataFusion and GeoArrow to build a powerful, unified engine that integrates easily with spatial and non-spatial data tools in the Python ecosystem. I'll discuss how to incorporate it into your data pipelines, with an emphasis on when to use it, how to make it efficient, and how to integrate it with other tools like DuckDB, Polars, or GeoPandas. PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/U9TNWY/ Room 1.38 (Ground Floor, Turing) Paweł Tokaj PUBLISH ZT3BMR@@pretalx.com -ZT3BMR Embed Data Science in your IoT device with MicroPython en en 20260721T163000 20260721T165000 002000

Embed Data Science in your IoT device with MicroPython

Typical Internet of Things devices send off most of the data to an external cloud service for analysis. This causes challenges both in terms of privacy, poor reliability under poor connectivity, and loss-of-availability when the service is discontinued. We would like to show that it is possible to achieve the majority of functionality using a local-first approach, including machine-learning based sensor-data analysis. And that this can done on low-cost microcontrollers such as ESP32. This talk will cover how to build stand-alone devices for measuring and analyzing physical sensor data, using MicroPython. This includes these aspects: - Measuring the surroundings using sensors - Connectivity using WiFi - Data storage using on-board filesystem - Serving a webui for configuration/control, using Microdot - Automated data processing/analysis using DSP and ML, with emlearn-micropython - Enabling interactive data analysis via webui - Managing concurrency on microcontroller, using asyncio - Optional integration. Pull using HTTP, and/or push using Webhooks/MQTT Slides: https://github.com/jonnor/embeddedml/tree/master/presentations/euroscipy2026/presentation PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/ZT3BMR/ Room 1.38 (Ground Floor, Turing) Jon Nordby PUBLISH E3X9EX@@pretalx.com -E3X9EX Automatic Reconstruction of X-ray Scenes with Python and DataLab en en 20260721T093000 20260721T100000 003000

Automatic Reconstruction of X-ray Scenes with Python and DataLab

This talk presents a real-world industrial application of scientific Python in the domain of X-ray imaging and geometric reconstruction. Unlike traditional image stitching techniques that rely on overlapping textures or acquisition metadata, this method is entirely driven by content-based detection of patterns embedded in the scene. Each sub-image undergoes a sequence of transformations culminating in the estimation of a homography, allowing precise alignment within a global coordinate system. A key aspect of the project was the ability to prototype, debug, and validate a highly parameterized image processing pipeline. Using [DataLab](https://datalab-platform.com), developers could: - interactively inspect intermediate images, - visualize detected patterns and geometric annotations, - adjust thresholds and filtering parameters, - compare transformation models in real time. This is a novel approach that significantly accelerated development and debugging, enabling rapid iteration on the image processing pipeline. The live demonstration will showcase how [DataLab](https://datalab-platform.com) facilitated the development process, providing insights into the algorithm's behavior and ensuring robustness before integration into a production software tool. The talk will include: - a walkthrough of the reconstruction strategy, - a discussion of the image processing challenges involved, - a live or recorded demonstration of the interactive prototyping environment with [DataLab](https://datalab-platform.com), - reflections on software architecture and reproducibility in scientific imaging workflows. This case study demonstrates how open-source scientific Python, especially when combined with interactive platforms like [DataLab](https://datalab-platform.com), can power advanced geometric reconstruction tasks in high-stakes industrial environments. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/E3X9EX/ Room 1.19 (Ground Floor, Shannon) Pierre Raybaut Marc Rabec le Gloahec PUBLISH RBUGDR@@pretalx.com -RBUGDR Boring AI Works: When BERT Beats Billion-Parameter Models en en 20260721T113000 20260721T115000 002000

Boring AI Works: When BERT Beats Billion-Parameter Models

Recently, LLMs have become the default answer to almost every NLP problem. Need classification? Prompt an LLM. Need tagging? Prompt an LLM. Need summarization? Prompt an LLM. It is undeniable that it works, but often at a cost that businesses quietly absorb without always seeing proportional value. This talk takes a step back and asks a simple question: Are we solving business problems, or just using the most trendy tools available? Through a real production case study, I’ll show how a fine-tuned BERT-based classifier solved a well-defined business problem more efficiently than an LLM-based alternative, with lower latency, reduced operational complexity, easier maintenance, and significantly lower cost. In constrained environments with standardized inputs and clear evaluation criteria, simpler transformer models can still be the most effective solution. Importantly, this is not an anti-LLM talk. LLMs play a valuable role in the workflow, from data exploration and labelling support to analytics such error analysis. But when it comes to production inference for well-defined tasks, smaller task-specific models often deliver the best performance-to-cost ratio. If AI is going to succeed in business, it won’t be because models are bigger, it will be because solutions deliver measurable impact without unsustainable cost or complexity. As data scientists and AI engineers, designing those efficient trade-offs is part of our responsibility. Sometimes, the most impactful AI solution is also the most boring one. PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/RBUGDR/ Room 1.19 (Ground Floor, Shannon) Diogo Rodrigues PUBLISH E8FCF9@@pretalx.com -E8FCF9 PyGambit & DrawTree: Python tools for game theory. en en 20260721T140000 20260721T143000 003000

PyGambit & DrawTree: Python tools for game theory.

The [“Gambit”]( https://www.gambit-project.org/) project for computation in game theory has been through multiple phases of development, dating back to the 1980s. Game theory as a field & methodology emerged from economics, but increasingly has applications in cybersecurity, multi-agent systems research and AI. Gambit is used across these fields for both teaching purposes, and as a suite of software tools for scientific computing. Recent Gambit development has been carried out at The Alan Turing Institute and has involved a modernisation of the PyGambit package, with a particular focus on improving the user experience, including clear user tutorials and documentation. This in turn has helped to guide the prioritisation of features in recent package releases, as well as the development of a new package called DrawTree, which creates (TeX/TikZ) game visuals for games constructed in PyGambit (working in Jupyter via the Jupyter-TikZ dependency). This talk will introduce some fundamental concepts in game theory using PyGambit, explaining how the package can be used to create non-cooperative games, and compute their Nash equilibria (where game players have no incentive to deviate their strategies). Secondly, the talk will demonstrate DrawTree and the 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. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/E8FCF9/ Room 1.19 (Ground Floor, Shannon) Ed Chalstrey PUBLISH 8KCT3D@@pretalx.com -8KCT3D The Illusion of Compliance: Auditing LLM-as-a-Judge Systems en en 20260721T144000 20260721T151000 003000

The Illusion of Compliance: Auditing LLM-as-a-Judge Systems

Consider a hiring model that shows equal acceptance rates for men and women, and equal rates for white and non-white candidates. Every single-axis dashboard is green. Yet Black women are rejected at nearly twice the rate of any other group. Social scientists call this intersectionality - the recognition that discrimination operates non-additively. A Black woman's experience isn't racism + sexism; the intersection creates distinct disadvantages. The bias doesn't disappear - it moves. We’ll walk through Python workflows that: - Move beyond single-attribute slicing to multi-dimensional group analysis - Implement additivity testing (quantify non-linear discrimination) - Detect dimensional heterogeneity (when gender improves but race worsens) - Surface trade-offs introduced by alignment and tuning Although the empirical case centers on hiring, the evaluation framework generalizes to any high-stakes LLM-as-Judge deployment. Attendees will leave with a reproducible evaluation framework grounded in 50 years of social science research, practical tools for EU AI Act compliance, and a clearer understanding of what meaningful compliance requires in regulated environments. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/8KCT3D/ Room 1.19 (Ground Floor, Shannon) Vasu Sharma PUBLISH 9UKDPK@@pretalx.com -9UKDPK PyCabinet: A Python Toolbox for End-to-End Transcriptomics and Omics Analysis en en 20260721T152000 20260721T154000 002000

PyCabinet: A Python Toolbox for End-to-End Transcriptomics and Omics Analysis

I am a PhD student, in cancer omics, and as I dive deep into analysis I constantly realize how difficult it would be for people in the field to work with tools scattered all over place. Hence I decided to work on this package. The thought of having everything organized complied in one place, is what it an easier and usable option for to start with the analysis, with a tool like this to guide. Also with the age of LLMs, the extension of this would be the bot trained on the common questions that we come across when starting in the field. PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/9UKDPK/ Room 1.19 (Ground Floor, Shannon) Ishita jain PUBLISH WENFS9@@pretalx.com -WENFS9 Unpacking parallelising NetworkX algorithms in nx-parallel backend en en 20260721T160000 20260721T162000 002000

Unpacking parallelising NetworkX algorithms in nx-parallel backend

We begin by briefly introducing NetworkX. As graph sizes increase and begin to reflect real-world networks, performance becomes a key consideration. This motivates the introduction of nx-parallel as an extension that enables multi-core execution while remaining aligned with the design philosophy of NetworkX. The discussion then focuses on embarrassingly parallel algorithms in the context of graph analysis—specifically, algorithms whose computations can be decomposed into independent tasks across nodes or edges. This establishes why only certain algorithms are suitable for parallelisation and frames the scope of nx-parallel accordingly. Next, we outline how these algorithms are parallelised using Joblib, including task partitioning, chunking strategies, the overhead of multiprocessing, and result aggregation. Then, we move on to a key optimization which involves leveraging memory mapping for large NumPy-backed graph data. By storing such data in a memory-mapped format, multiple worker processes can access the same underlying data from disk without duplicating it in memory, thereby reducing overhead for large graphs. Then, I introduce should_run heuristics, which determine whether parallel execution is beneficial for a given workload, ensuring that parallelism is applied only when appropriate. Finally, the flow concludes with a small demonstration comparing NetworkX and nx-parallel across different graph sizes, using heatmaps to visualise observed speedups and highlight where parallel execution provides measurable performance improvements. PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/WENFS9/ Room 1.19 (Ground Floor, Shannon) Akshita Sure PUBLISH EBDPBB@@pretalx.com -EBDPBB Lessons from Building a Large-Scale Engineering Simulation Data Processing Library en en 20260721T163000 20260721T165000 002000

Lessons from Building a Large-Scale Engineering Simulation Data Processing Library

Large simulation datasets arise in many scientific domains, from engineering and physics to computational biology and geoscience. While Python is the preferred language for many researchers and scientists due to its simplicity, interactivity, and rich ecosystem; high-performance workflows for pre-processing and post-processing large simulation datasets often requires the integration 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. Developing and maintaining such a library poses several interconnected challenges, especially when a client-server architecture is preferred between the backend and the Python interface. These challenges manifest themselves in various ways, such as: making the underlying data model sufficiently abstract and self-describing to maximize applicability across multiple scientific domains; ensuring the data processing pipeline is composable and modular; decoupling the evolution of the server from that of the client; limiting data transfers between the client and the server; managing growing server APIs on the client side; visualizing the processed data; and ensuring up-to-date library documentation alongside development efforts among other things. This talk will touch how each of these challenges have been solved by briefly examining the following: - Modelling data that is "aware" of what it describes - The hourglass interface pattern for ensuring that the Python client and C/C++ server can independently evolve - Operator-based pipelines for composable data processing workflows - Techniques for reducing client-server data transfers - Templating and automated code generation techniques for API scalability - Leveraging third party python libraries for data visualization - Sustainable CI/CD practices for testing and library documentation generation. Pre-requisites: - No deep C/C++ knowledge required, the talk is not intended to be technical - Basic understanding of client-server concepts References: - PyDPF-Core repository: https://github.com/ansys/pydpf-core - Documentation: https://dpf.docs.pyansys.com/ - Hourglass Interface pattern: CppCon talk on stable ABI boundaries PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/EBDPBB/ Room 1.19 (Ground Floor, Shannon) Muhammed Adedigba PUBLISH QJRACH@@pretalx.com -QJRACH setu: Bridging Simulators to Probabilistic Programming in JAX en en 20260721T113000 20260721T120000 003000

setu: Bridging Simulators to Probabilistic Programming in JAX

### Background and motivation Simulation-based inference (SBI) has emerged as a powerful set of methods for performing Bayesian inference with simulator models that lack tractable likelihoods. Packages like `sbi` (PyTorch) have made these methods accessible to Python users. However, a key limitation remains: SBI methods typically produce standalone posterior approximations, disconnected from the broader probabilistic programming ecosystem. Last year at EuroSciPy 2025, we presented work on bridging SBI to `pyro` for hierarchical Bayesian inference: enabling flexible design of multi-level models for intractable simulators. While promising, this approach was tightly coupled to the `sbi` package's PyTorch ecosystem and Pyro's specific API, making it difficult for users of other PPLs (PyMC, NumPyro) to benefit. This motivated a fundamental rethinking: rather than building bridges from within existing packages, we built `setu`, a standalone, JAX-native package purpose-built for one thing: learning neural likelihood (ratio) surrogates from simulators and exporting them to any PPL. ### What `setu` does 1. **Simulate**: Run your simulator to generate paired (parameter, data) samples. Usually happens on the user side, but `setu` provides utilities for parallelization. 2. **Train**: Fit a normalizing flow (masked autoregressive flows or neural spline flows) to learn the conditional density p(data | parameters) — the likelihood. 3. **Validate**: Before trusting the learned likelihood, run built-in diagnostic checks: classifier two-sample tests (C2ST), distribution shift detection, and training convergence monitoring. 4. **Export**: Call `.to_pymc()` or `.to_numpyro()` to get a likelihood term you can drop into any PPL model. The learned log-probability integrates seamlessly with the PPL's inference engine. ### Why JAX? Building natively in JAX was a strategic choice: - **PyMC integration**: PyMC's backend (PyTensor) has a direct JAX compilation path, making the bridge nearly zero-overhead. - **NumPyro**: Already JAX-native, so the integration is trivial. - **Performance**: JAX's JIT compilation and automatic differentiation provide significant speedups for both training and inference, especially in hierarchical models where the learned likelihood is evaluated many times. ### Talk outline (25 minutes) 1. **The problem** (5 min): Why most simulators cannot be used in PPLs, and why this matters for scientific inference. We introduce the running example: hierarchical modeling of tadpole survival across experimental tanks, a classic problem from ecology (Vonesh & Bolker, 2005), well known through the *Statistical Rethinking* lectures. 2. **The idea** (5 min): Neural likelihood estimation in a nutshell; what normalizing flows learn, and why this enables the use of PPLs. We validate `setu` by showing its performance vs. PyMC on the fully tractable Binomial tadpole survival model. 3. **setu in practice** (10 min): We extend the tadpole example to an individual-based mechanistic simulator with size-dependent predation and density-dependent competition (Vonesh & Bolker, 2005), which results in an intractable likelihood. Using `setu`, we train a neural likelihood, export it to PyMC, and perform hierarchical inference across all 48 tanks. This would be challenging with standard PPLs or standalone SBI. 4. **Validation matters** (3 min): Why you must check your learned likelihood before trusting it, and how it is done in `setu`. 5. **Ecosystem and future** (2 min): Current status, roadmap, and how to get involved. ### Key takeaways for the audience - Neural density estimation can turn simulators into a likelihood function usable by PPLs. - The simulate, train, validate, export workflow makes this practical and safe. - `setu` is designed for scientists who already know PyMC or NumPyro and want to use their real simulators instead of simplified analytical models. - Validation is essential: approximate likelihoods need rigorous checking. ### Relevance to EuroSciPy This talk sits at the intersection of several EuroSciPy themes: scientific Python infrastructure, numerical simulation frameworks, and statistical/mathematical computing. It addresses a real and growing need across disciplines where scientists have sophisticated simulators but lack the statistical tools to perform proper Bayesian inference with them. The running example builds on the Reed Frogs dataset familiar to many from *Statistical Rethinking*, making the problem immediately accessible before we extend it beyond what textbook methods can handle. The package is open source, JAX-native, and integrates with the most widely-used PPLs in the Python ecosystem. PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/QJRACH/ Room 2.41 (First Floor, Turing) Jan Boelts (Teusen) sethaxen PUBLISH VHAXMC@@pretalx.com -VHAXMC Interactive visualizations anywhere en en 20260721T140000 20260721T143000 003000

Interactive visualizations anywhere

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). PUBLIC CONFIRMED Talk (25 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/VHAXMC/ Room 2.41 (First Floor, Turing) Almar Klein PUBLISH 79VCDC@@pretalx.com -79VCDC Teaching scientific programming in the age of agentic coding en en 20260721T152000 20260721T154000 002000

Teaching scientific programming in the age of agentic coding

In the past decades, the methods for teaching programming were revamped from classroom- and examination-oriented teaching into a learning experience filled with live demos and type-along sessions in workshops. This process, which involved interleaving exercises with lectures and using literate programming tools such as Jupyter, was championed by The Carpentries. Today this practice has influenced CodeRefinery, EuroCC2 and several local and non-profit organizations in making learning technology truly a rewarding experience. However, this approach still relies on teaching certain topics, which should be questioned and revisited in today's age of agentic coding: - Discoverability of libraries - Knowledge of which libraries to use and in which context were one of experience and recommendations. Such advice usually spreads organically, through word of mouth, blogs by seasoned developers, or forums such as StackOverflow. - Good practices - From writing good, professional-looking code to using design patterns were achievable using a spectrum of tools. This ranges from using formatters and linters to organically developing a coding style through experience and by reading code written by others. - Memorizing syntax - Traditionally this is done by following tutorials and reading documentation. - Performance optimization - This is considered an advanced art, which requires combining multiple profiling tools to analyze hotspots. The process often entails writing foreign function interfaces and extensions using source-to-source compilers to optimize and parallelize slow code. - Exploratory programming and problem solving - Going from a problem statement or a list of specifications, paired with a dataset, towards the goal of working code involves the choice between paradigms such as functional programming versus object-oriented programming, along with techniques such as test-driven development (TDD), debugging and visualization. If the current and future generations of learners are using LLMs as the first choice to guide them, instead of rigorously learning the above, are we teaching programming incorrectly? This is not a comprehensive list and there are potentially many such topics which need to be taught with an agentic coding perspective. LLMs could be part of the solution but still suffers from many drawbacks. The open question is how do we teach this and use this reliably? PUBLIC CONFIRMED Talk (15 mins + Q&A) https://pretalx.com/euroscipy-2026/talk/79VCDC/ Room 2.41 (First Floor, Turing) Ashwin Mohanan PUBLISH D9FJAC@@pretalx.com -D9FJAC Deal with imbalanced classification using scikit-learn en en 20260722T090000 20260722T103000 013000

Deal with imbalanced classification using scikit-learn

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 PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/D9FJAC/ Room 1.38 (Ground Floor, Turing) Guillaume Lemaitre Anne Beyer PUBLISH MYVDAK@@pretalx.com -MYVDAK Do you know how well your model is doing? Evaluate your LLMs en en 20260722T110000 20260722T123000 013000

Do you know how well your model is doing? Evaluate your LLMs

Prerequisites: Have experience coding in Python (with Python installed in the local machine) Basic understanding of machine learning and LLMs Experience with Hugging Face Transformers is preferred but not necessary A Hugging Face Hub account (sign up for free) A modern computer that can fine-turn small LLMs locally Description: We will begin with an essential revision of the Hugging Face Transformers library, covering basic LLM inference and fine-tuning. The core of the workshop will introduce and provide deep practice with Lighteval, an efficient and powerful LLM evaluation framework. Participants will learn how to leverage Lighteval to compare various LLMs available on the Hugging Face Hub using a range of pre-built tasks and metrics. Finally, we will delve into advanced evaluation techniques, focusing on creating custom tasks and metrics tailored to unique, real-world application requirements. Participants will learn how to prepare custom datasets on the Hugging Face Hub and integrate them into Lighteval for precise, domain-specific evaluation. By the end of this workshop, you will possess the practical skills to rigorously evaluate, benchmark, and fine-tune your LLMs with confidence. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/MYVDAK/ Room 1.38 (Ground Floor, Turing) Cheuk Ting Ho PUBLISH CGY37C@@pretalx.com -CGY37C Quantum Physics Simulations using QuTiP en en 20260722T140000 20260722T153000 013000

Quantum Physics Simulations using QuTiP

QuTiP (Quantum Toolbox in Python) is an oopen-source library that is used for a wide range of applications in quantum physics research. While offering sophisticated tools for advanced use cases, QuTiP stays accessible for anybody from student to professional. Therefore, in this tutorial, we will start with the basic functionality of QuTiP and work our way up to more involved examples. For starters, we will look at simple dynamics of interacting qubits. This will introduce the language of QuTiP and teach us how to traanslate a physical problem into code. After this step we will add an environment to the plate, that will influence our qubit system. Although, by doing so, the math behind the problem changes completely, QuTiP requires only very few extras to fully calculate the dynamics. For the more advanced use cases, we will look at the QuTiP QIP package for quantum information processing. This package offers a large toolbox for quantum computing simulations. Features range from circuit construction all the way to hardware emulation. To explore this part of the QuTiP ecosystem, we will implement the quantum teleportation protocol. We will construct the circuit, look at its translation to native gates and finally run it on emulated superconducting hardware. Come and join this tutorial to learn how quantum physical questions can be translated into Python and how QuTiP helps shape the future of quantum technologies. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/CGY37C/ Room 1.38 (Ground Floor, Turing) Maximilian Meyer-Mölleringhof Alexander Pitchford PUBLISH HX7ZZJ@@pretalx.com -HX7ZZJ Introduction to Profiling en en 20260722T160000 20260722T173000 013000

Introduction to Profiling

This tutorial introduces attendees to the fundamentals of profiling in Python—why, what, when and how to profile. In the first half, we demonstrate function-level profiling using the Python standard library’s `cProfile` module and visualise its results with the `snakeviz` module. In the second half, we demonstrate line-level profiling using `line_profiler`/`kernprof`. Finally, we’ll give an outlook on the new `profiling` module and Tachyon sampling profiler coming in Python 3.15 this autumn. Throughout the tutorial, we use two types of interactive exercises: Firstly, short toy examples, which are designed to demonstrate each tool in an approachable manner. Secondly, we will investigate a more complex example code using each of these tools in turn, to demonstrate how they build on each other. Attendees will get hands-on experience using these tools to systematically investigate performance issues in a Python code base. **Schedule:** Introduction: Why, What & When to Profile (10 min) Function-Level Profiling with cProfile (25 min) Visualising cProfile Results (15 min) Line-Level Profiling (25 min) Outlook: Changes in Python 3.15 (10 min) Conclusion & Next Steps (5 min) This tutorial is based on a course on Python Profiling and Optimisation developed as part of the Carpentries Incubator program. The profiling section of that course is designed to be delivered independently; it requires only minor adjustments to scope and timings to fit the 90 min tutorial time slot. As a contributor and co-maintainer, I have previously delivered this course at multiple institutions. I have also presented a brief talk introducing the course at EuroSciPy 2025. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/HX7ZZJ/ Room 1.38 (Ground Floor, Turing) Jost Migenda PUBLISH SVL9NV@@pretalx.com -SVL9NV Reproducible Dependency Management with Pixi en en 20260722T090000 20260722T103000 013000

Reproducible Dependency Management with Pixi

Managing dependencies can be a complex task, especially when it comes to multi-platform support and extensions written in compiled languages, such as C/C++ or Rust, are involved. There are many tools for Python that can help to take care of different aspects of this problem. These tools are external Python packages that are not distributed with Python itself. Only `pip` is installed by default. Other, more recent languages such as Rust, include the tooling for dependency management as part of the core language. On the other hand, the Python ecosystem for dependency management is very fragmented. In general, there are two main approaches (a) based on pip packages and (b) based on conda packages. Pixi offers an approach that can work with both package types. Its design is inspired by Rust's cargo. In addition to Python packages, pixi can also manage software written in other languages. For example, using conda-forge as the default conda repository, Pixi can install tools such as `gcc`, `pandoc`, or `git`. Pixi can work tother with existing tools such as `setuptools` or `poetry`. In fact, it uses `uv` internally to install pip packages. ## Audience This tutorial is for participants who: 1. Have a solid Python knowledge 2. Are familiar with the **basic** use of `pip` or similar tools 3. Would like to learn what pixi brings to dependency management 4. Would like get hands-on experience with Pixi PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/SVL9NV/ Room 1.19 (Ground Floor, Shannon) Mike Müller PUBLISH QAUJYS@@pretalx.com -QAUJYS Developing IoT sensors with MicroPython en en 20260722T110000 20260722T123000 013000

Developing IoT sensors with MicroPython

Materials: https://github.com/jonnor/micropython-iot-sensors-course ## Section 1: Basics — Running in Simulator (Wokwi) 1. Introduction — Microcontroller / MicroPython / Wokwi 2. Analog and Digital GPIO 3. Concurrency with Asyncio 4. Digital Bus (I2C) 5. Talk to Servers using HTTP Client 6. IoT Networks using MQTT ## Section 2: Running on Device (RPi Pico) 1. Deploying on Device with mpremote 2. Standalone IoT Device with HTTP Server and WebUI ## Section 3: Running MicroPython on PC 1. Install & Run MicroPython on Linux/macOS/Windows ## Section 4: Advanced Topics (Self Study) 1. Installing MicroPython on Device (ESP32, RP2) 2. Efficient Code — JIT Decorators, Inline Assembler, C Modules 3. DSP and Machine Learning with emlearn-micropython 4. MicroPython for Embedded Linux PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/QAUJYS/ Room 1.19 (Ground Floor, Shannon) Jon Nordby PUBLISH FL89YS@@pretalx.com -FL89YS From Black to White Boxes: Interpretable Regression with the trust-free Python package en en 20260722T140000 20260722T153000 013000

From Black to White Boxes: Interpretable Regression with the trust-free Python package

**Tutorial Summary and Learning Objectives** This hands-on workshop introduces **TRUST** (**T**ransparent, **R**obust, and **U**ltra-**S**parse **T**rees), a novel interpretable machine learning framework, and demonstrates its implementation using the Python package `trust-free`. The tutorial is designed to solve the critical trade-off in industrial ML: achieving high predictive accuracy without sacrificing model interpretability. Attendees will move beyond black-box models and learn how to fit high-performing regression trees where every split, every leaf, and every final prediction is inherently explainable. By the end of this 90-minute session, attendees will be able to: 1. Successfully fit a high-accuracy, interpretable regression model using the `trust.TRUSTRegressor()` class. 2. Understand the difference between standard Decision Trees (CART) and Linear Model Trees (LMTs), and interpret the sparse linear models generated at the leaves of the TRUST framework. 3. Generate and interpret automated, natural-language explanation reports for any single prediction using the powerful `.explain()` method. 4. Use the unique `.compare()` method to contrast two observations head-to-head, immediately highlighting the features responsible for prediction differences. **Prerequisites and Setup** - **Target Audience**: Data Scientists and Data Analysts focused on building highly accurate, accountable, and interpretable regression models. The tutorial is especially valuable for those needing to communicate model outputs clearly to non-technical stakeholders (e.g., line managers, regulators, or the general public). - **Required Knowledge**: Intermediate Python (familiarity with `pandas`, `numpy`, `scikit-learn`, and Jupyter notebooks) and basic knowledge of regression concepts (R², feature importance, cross-validation). - **Required Software**: Attendees should ideally have the following installed prior to the tutorial: - Python 3.11 or 3.12 - The `trust-free` package (`pip install trust-free`) - Jupyter Notebook or similar notebook environment. - **Compatibility Note**: A link to a Google Colab notebook environment will be provided to ensure all participants can run the code immediately, regardless of their local machine setup or operating system architecture. - **Dataset**: We will use a pre-cleaned, publicly available regression dataset (the famous Medical Insurance Charges dataset). **90-Minute Detailed Outline** This workshop is structured with a strong emphasis on practical application, dedicating approximately 70% of the time to live coding and guided exercises. - **[0-10 min] LMT Theory and Setup**: Conceptual introduction to Linear Model Trees (LMTs) and how TRUST achieves sparsity and accuracy. Environment check and quick review of the starter code repository. - **[10-25 min] Model Fitting**: Loading data and preparing it for regression. Hands-on Exercise 1: Fitting the `trust.TRUSTRegressor()` model and introduction to key parameters. - **[25-40 min] Global Interpretation of the Fitted Model**: Understanding the decision process: how TRUST defines splits. Code Demo: Visualizing the full tree structure (`.plot_tree()`), interpreting the sparse linear model coefficients within the leaf nodes, and state-of-the-art global variable importance scores. - **[40-65 min] Individual Prediction Explanations**: The power of the `.explain()` method. How to generate automated, comprehensive reports that justify a single prediction, including local variable importance and human-readable text summaries. Hands-on Exercise 2: Generating and analyzing individual explanation reports. - **[65-75 min] Head-to-Head Instance Comparison**: Using the unique `.compare()` feature to visually and statistically contrast why two different data points received different predictions. Hands-on Exercise 3: Comparing the profiles of two example observations. - **[75-90 min] Wrap-up and Q&A**: Summary of key takeaways and resources for further exploration. Final Q&A. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/FL89YS/ Room 1.19 (Ground Floor, Shannon) Albert Dorador PUBLISH Y7YM3G@@pretalx.com -Y7YM3G Same Recipe, Different Results: Fine-Tuning Models Across Modalities en en 20260722T160000 20260722T173000 013000

Same Recipe, Different Results: Fine-Tuning Models Across Modalities

Fine-tuning has become the default way to adapt foundation models to specific tasks, but most of the conversation focuses on text. If you have fine-tuned an LLM with LoRA or QLoRA, you might assume the jump to other modalities is straightforward as the core idea is the same. In practice, each modality comes with its own assumptions, failure modes, and hard-won lessons that only become obvious once you start training. This talk walks through fine-tuning across four modalities side by side, highlighting the patterns that hold and the ones that break. For text (LLMs), we start with the standard recipe as a baseline (LoRA, dataset formatting, evaluation), and focus is on identifying the implicit assumptions in the text workflow that do not carry over to other modalities. For images (Diffusion Models), we walk through fine-tuning for specific visual styles that look similar on the surface, but for which the data preparation is fundamentally different. We will cover why image adaptation is far more sensitive to dataset size and composition than text, and the tradeoffs between different techniques. For audio, we will look at fine-tuning a model to generate music in a specific genre using publicly available data, and how audio tagging models can be paired with embeddings to build applications that connect generation with semantic understanding of music. Video, as the least documented modality, has frame sampling strategies, temporal consistency, and compute requirements that escalate faster than you would expect. We will cover the current state of video model adaptation and where the tooling still has rough edges. Once you have multiple fine-tuned models, merging offers a way to combine their capabilities without retraining. We will cover the main strategies and when merging is a shortcut worth taking versus when it will produce sub-optimal outputs. Across all modalities, we will compare data preparation, training configuration, evaluation, and the current state of open-source tooling. All code examples use Python with HuggingFace Transformers, Diffusers, and related libraries, and every example uses publicly available models and datasets. The goal is to give you the comparative mental model that makes moving between modalities far less intimidating, and to show that with the right tools and a bit of curiosity, the same recipe can produce very different and very satisfying results. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/Y7YM3G/ Room 1.19 (Ground Floor, Shannon) Ramon Perez PUBLISH VLTW7C@@pretalx.com -VLTW7C Introduction to Differentiable Programming en en 20260722T140000 20260722T153000 013000

Introduction to Differentiable Programming

**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. Despite its great potential, it’s not uncommon for developers to move along when they happen across this topic, leaving it to the “ML guys” and repressing bad memories from calculus class. But it doesn’t have to be that way! In fact, a big part of the differentiable programming offering is exactly to offload having to calculate derivatives and gradients manually. The tutorial will cover the basics of differentiable programming, where I’ll guide you as you solve differentiable programming challenges, starting with toy problems up to simple 3D reconstruction. **You’ll learn how to**: * Identify problems where differentiable programming is applicable * Formulate problems for differentiable programming * Monitor and debug the optimization process *Target audience*: Solid proficiency with basic scientific python is required for the tutorial (functions, control flow, vector operations). There will be math, but I promise it will be light and handled gently. *Is this tutorial just for ML people*? Absolutely not! Differentiable programming has applications beyond the world of ML, and you don’t need to know fancy math to use it. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/VLTW7C/ Room 2.41 (First Floor, Turing) Daniel Anderson PUBLISH H9UDLT@@pretalx.com -H9UDLT A Hands-On Introduction to Mechanistic Interpretability en en 20260723T090000 20260723T103000 013000

A Hands-On Introduction to Mechanistic Interpretability

We work through four concrete investigations: * We extract the token embedding matrix and apply PCA to ask whether vowels and consonants form geometrically distinct clusters — testing the hypothesis that the model has learned something about phonetic structure purely from next-character prediction. * We extract attention weight matrices for specific inputs and visualise them as heatmaps, then run a simple hypothesis test (via scipy.stats) asking whether the model attends more strongly to repeated characters. * We perform systematic head ablation — zeroing individual attention heads and measuring loss change — to identify which heads are load-bearing and which are redundant. * We use the gradients already computed by microgpt's autograd engine to perform logit attribution: tracing which embedding dimensions most strongly influenced a given prediction. Participants will leave with a modular, reusable codebase, a concrete mental model for mechanistic interpretability, and pointers to how these techniques scale to production models via TransformerLens and Anthropic's circuits research. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/H9UDLT/ Room 1.38 (Ground Floor, Turing) Vasu Sharma PUBLISH 8TC88B@@pretalx.com -8TC88B Gluing SciPy, Numba, and Pint to Bridge High Performance with Maintainability en en 20260723T110000 20260723T123000 013000

Gluing SciPy, Numba, and Pint to Bridge High Performance with Maintainability

In this tutorial, we will implement a simple yet non-trivial ODE-based physical model. Rather than relying on unmaintainable code comments to annotate values with units, we will use the Pint package to programmatically attach physical units to scalars and arrays, enabling dimensional analysis of the codebase (e.g., ensuring that adding Newtons to Joules raises an exception). We’ll also explore how Pint handles unit conversions and automatic plot axis labeling. The key challenge we’ll tackle is refactoring the code to make it JIT-compilable with Numba, and compatible with Fortran-implemented ODE solvers from SciPy, all while preserving Pint functionality! PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/8TC88B/ Room 1.38 (Ground Floor, Turing) Sylwester Arabas Kamil Kania PUBLISH AYPWY3@@pretalx.com -AYPWY3 Version Everything: From Chaos to Order in Reproducible Python Projects en en 20260723T140000 20260723T153000 013000

Version Everything: From Chaos to Order in Reproducible Python Projects

The workshop is ideal for data scientists, researchers, and Python developers with intermediate experience who are tired of “works on my machine” syndrome. You’ll gain hands-on experience with modern tools and practices that make Python workflows reproducible, maintainable, and easy to share, all while applying them to simply data science tasks. Starting with a messy but working data analysis project, we’ll systematically add reproducibility layers through guided coding exercises. Modules: - Modern Dependency Management (10 min): Creating lock files, managing Python versions - Code & Configuration Versioning (30 min): Git for source code, configuration files for parameters - Data Pipeline Versioning (30 min): DVC setup, pipeline definitions, experiment tracking - Hidden Reproducibility Challenges (10 min): Randomness and human error - Production Deployment (10 min): Containerization, artifact registries, deployment reproducibility The workshop is ideal for data scientists, researchers, and Python developers with intermediate experience who are tired of “works on my machine” syndrome. Prerequisites: - A laptop with admin privileges to install tooling - Basic knowledge of Python syntax and the command line PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/AYPWY3/ Room 1.38 (Ground Floor, Turing) Aris Nivorlis PUBLISH TRFRMH@@pretalx.com -TRFRMH napari: explorative visualization and workflow building for scientific data analysis en en 20260723T090000 20260723T103000 013000

napari: explorative visualization and workflow building for scientific data analysis

Data exploration and workflow building are two often overlooked aspects of scientific data processing and visualization. Commonly discussed tools often focus on un-interactive publication figures or pre-packaged, highly specialized software suites. If exploratory visualization constitutes a large part of your interaction with scientific data - if you often need to develop or adapt processing workflows but struggle to customize existing visualization and annotation software - if you're looking for a smoother experience that allows you to both write processing code and *actually see what it does* - then this tutorial is for you. To get the most out of this tutorial, some experience with general scientific Python tooling and libraries is advised (mostly NumPy and its syntax). Ideally, you should have some idea of how data and images are represented as arrays of numbers, and the types of analyses that might be performed on these arrays, e.g. filtering and segmentation. You don’t necessarily need to be familiar with how these tools and methods work - it’s enough to know that they are out there! ### Introduction to napari (~20-30 min) We will begin with a short introduction to napari, the main components of its interface, and some important features. We will also make sure everyone can get a virtual environment set up with napari. You will have some time to play around with some sample data, get comfortable with the interface and ask some questions. ### Exploratory analysis (~45-60 min) In this section, we will simulate a typical session of data exploration, developing a small image processing workflow along the way. You will start with a small pure-python example, gradually making it more powerful and interactive by converting it to a napari widget and by integrating it with existing napari functionality such as the grid view, command palette, overlays, etc. ### Making a plugin (~10-15 min) To finish up, you will learn how to take the previously written code and convert it to a napari plugin, publishing it as a python package that everyone can easily install and reuse. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/TRFRMH/ Room 1.19 (Ground Floor, Shannon) Lorenzo Gaifas Grzegorz Bokota PUBLISH ZFSAVF@@pretalx.com -ZFSAVF Introduction to Data Science with Python: Pandas and Polars en en 20260723T110000 20260723T123000 013000

Introduction to Data Science with Python: Pandas and Polars

This beginner-friendly tutorial provides a practical introduction to the essential tools and techniques used in Python-based data science. The tutorial will cover: - An overview of the Python data science ecosystem - Loading datasets using Pandas and Polars - Inspecting data structures and understanding data types - Cleaning and preparing data for analysis - Selecting, filtering, and transforming data - Computing summary statistics and performing basic aggregations - A brief comparison of Pandas and Polars, including syntax and performance considerations The session is prepared for participants to follow along in Jupyter notebooks and complete short exercises throughout the tutorial. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/ZFSAVF/ Room 1.19 (Ground Floor, Shannon) Justyna Szydłowska-Samsel PUBLISH LL8N7L@@pretalx.com -LL8N7L Deploying and debugging GPU accelerated Python workloads en en 20260723T140000 20260723T153000 013000

Deploying and debugging GPU accelerated Python workloads

## Audience This is a hands-on tutorial, participants should ideally have some experience using Python, pandas and sci-kit learn. We'll use cloud-based VMs, so familiarity with the cloud and resource creation is helpful but not required. No prior GPU knowledge is needed. To maximize the tutorial's relevance, we will provide participants with the opportunity to submit their specific environment configurations ahead of time. Submissions received with adequate notice (between tutorial acceptance and conference date) will be integrated into the tutorial examples, allowing participants to see their real-world use cases addressed. Key takeaways for participants will be: - An understanding of the GPU Python software stack from driver through core libraries to high-level Python libraries - How they can use their preferring tooling and package managers to install all the components they need - How to monitor their GPUs and understand how well they are using their hardware - How to attach debuggers to their GPU code or record traces and profiles for debugging later ## Notes This is a hands-on tutorial, we expect the audience to follow along with the material in an active manner. It will also include exercises to do during the tutorial. ## Format In the session we will be walking through the material as a lecture and students will be following along on their own VMs. So the whole thing is an interwoven mix of lecture and exercises. We want students to be as hands on as possible to get a deep understanding of the software environment they are setting up. We also want students to direct the material so that it can be as close to their real world use cases. We will give students an opportunity ahead of the conference to tell us about their software environments so that we can tailor material to them. We will also have a "choose your own adventure" style in some sections where we can put more emphasis on one tool over another depending on who is in the room. For example when covering package managers we will have material for pip, conda, uv and pixi, but we will survey the room and then cover the relevant ones to the audience. ## Internet requirements Participants will be given access to a cloud VM which they will access via SSH or the Jupyter web UI. Both of these have very low bandwidth requirements, but will require an active connection. ## Outline - 0 mins- Intro and Setup - Introduce common libraries and tools where GPUs are leveraged in Python - Show some quick demos of how to run Python code that uses the GPU - 15 mins - How do I get a GPU? - Give participants access to cloud GPU resources - While the VMs start we will talk about alternatives - Everyone has their own tool and vendor preferences but the principles are the same - 30 mins - An exploration of Python package managers - pip, conda, uv and pixi are just some of the popular package managers - You can install GPU software with all of them, but there are differences and nuances - Participants will set up various GPU Python environments with these tools to get an understanding of the need to know differences - 50 mins - Monitoring - Running GPU accelerated Python code is just like running normal code - We will see how to verify our code really is being GPU accelerated - Participants will run examples and gather metrics on utilization and memory use with various tools - 70 mins - Debugging - Once you run some code you need to understand how it is performing - When your code crashes you need to debug and inspect what went wrong - GPU libraries can abstract complexity away, making them harder to debug - Participants will install and use various debugging tools to explore how to debug GPU accelerated code examples - 90 mins - Close PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/LL8N7L/ Room 1.19 (Ground Floor, Shannon) Jacob Tomlinson PUBLISH AMHGUK@@pretalx.com -AMHGUK Microwave Image Processing: Exploring realms of Earth through spaceborne Radars using Python en en 20260723T140000 20260723T153000 013000

Microwave Image Processing: Exploring realms of Earth through spaceborne Radars using Python

Intended Audience : The workshop will be aimed at the audience belonging to any level of education. It will introduce them to the wonderful class of SAR images and help them develop a clear perspective of various applications. Post workshop, the audience will be : i) Able to understand the acquisition of SAR imagery. ii) Able to understand the types of datasets utilized in remote sensing iii) Able to use the GDAL library to perform operations on images iv) Able to efficiently process SAR imagery using Python v) Able to draw a roadmap in order to utilize SAR imagery for various geographic applications Outline The workshop will be divided into the following sub-sessions : Sub-Session-1: Introduction to Microwave Remote Sensing (15 minutes) - This part will discuss the foundations of Microwave Remote Sensing. Theoretical aspects regarding the acquisition of images, the formation of images encompassing the generation of complex images and ground range detected images will be discussed. Sub-Session-2: Pythonic Way to SAR Image Processing (75 minutes): This part will focus on achieving the following Key points: 1) Basic utilization of GDAL, Numpy and Matplotlib Libraries for opening and visualizing Images(25 minutes) 2) Codes will be developed separately for calibration for each SAR sensor(esp. Sentinel-1, Radarsat-2) from scratch.(25 minutes) 3) Utilization of the codes developed in (2) for various applications such as Oceanography, Forestry, etc.(25 minutes) Datasets: Free Imagery data sets of Sentinel-1 SAR will be utilized. In addition, Sample Data sets of Radarsat-2, RISAT- 1 which are freely downloadable will be utilized.The sample datasets will be provided. Sentinel-1 Free SAR Imagery is available at https://browser.dataspace.copernicus.eu/ Conduct of the workshop : The workshop will be conducted through the means of Jupyter Notebooks. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2026/talk/AMHGUK/ Room 2.41 (First Floor, Turing) Shubham Sharma