{"$schema": "https://c3voc.de/schedule/schema.json", "generator": {"name": "pretalx", "version": "2026.3.0.dev0", "url": "https://pretalx.com"}, "schedule": {"url": "https://pretalx.com/euroscipy-2026/schedule/", "version": "0.31", "base_url": "https://pretalx.com", "conference": {"acronym": "euroscipy-2026", "title": "EuroSciPy 2026", "start": "2026-07-18", "end": "2026-07-23", "daysCount": 6, "timeslot_duration": "00:05", "time_zone_name": "Poland", "colors": {"primary": "#0056aa"}, "rooms": [{"name": "Room 1.38 (Ground Floor, Turing)", "slug": "5298-room-138-ground-floor-turing", "guid": "968e0c9c-b2a2-5072-9a86-297195d79aba", "description": null, "capacity": null}, {"name": "Room 1.19 (Ground Floor, Shannon)", "slug": "5299-room-119-ground-floor-shannon", "guid": "324387a6-0067-5ff0-a047-b6cf1d4422ff", "description": null, "capacity": null}, {"name": "Room 2.41 (First Floor, Turing)", "slug": "5301-room-241-first-floor-turing", "guid": "5ec07e62-b572-5823-98a6-b7acd20cbdad", "description": null, "capacity": null}, {"name": "Room 3.27b (Second Floor, Turing)", "slug": "5302-room-327b-second-floor-turing", "guid": "b85f9c34-b68a-5be0-8405-8434e97ffe58", "description": null, "capacity": null}, {"name": "Room 3.27c (Second Floor, Turing)", "slug": "5303-room-327c-second-floor-turing", "guid": "dedd9788-8562-5257-a60c-ea30dad6cce9", "description": null, "capacity": null}, {"name": "Echo Miasta", "slug": "5648-echo-miasta", "guid": "2224fded-7ed5-5a3f-841e-d57d1767994a", "description": null, "capacity": null}], "tracks": [{"name": "Community, Education, and Outreach", "slug": "6828-community-education-and-outreach", "color": "#665500"}, {"name": "Computational Tools and Scientific Python Infrastructure", "slug": "6829-computational-tools-and-scientific-python-infrastructure", "color": "#010101"}, {"name": "Interdisciplinary Frontiers and other Scientific Python Applications", "slug": "6830-interdisciplinary-frontiers-and-other-scientific-python-applications", "color": "#116633"}, {"name": "Physical Sciences and Engineering", "slug": "6831-physical-sciences-and-engineering", "color": "#990099"}, {"name": "Life Sciences and Biomedicine", "slug": "6832-life-sciences-and-biomedicine", "color": "#662222"}, {"name": "Environmental and Earth Sciences", "slug": "6833-environmental-and-earth-sciences", "color": "#AA2222"}, {"name": "Large Language Models (LLMs), Neural Networks and AI Development", "slug": "6834-large-language-models-llms-neural-networks-and-ai-development", "color": "#5533AA"}, {"name": "Applied AI & LLM Technologies and Use Cases", "slug": "6835-applied-ai-llm-technologies-and-use-cases", "color": "#006622"}], "days": [{"index": 1, "date": "2026-07-18", "day_start": "2026-07-18T04:00:00+02:00", "day_end": "2026-07-19T03:59:00+02:00", "rooms": {}}, {"index": 2, "date": "2026-07-19", "day_start": "2026-07-19T04:00:00+02:00", "day_end": "2026-07-20T03:59:00+02:00", "rooms": {}}, {"index": 3, "date": "2026-07-20", "day_start": "2026-07-20T04:00:00+02:00", "day_end": "2026-07-21T03:59:00+02:00", "rooms": {"Room 1.38 (Ground Floor, Turing)": [{"guid": "db53b0b5-568d-5710-abdf-cd0c08b45c9c", "code": "37RGPY", "id": 91167, "logo": null, "date": "2026-07-20T09:30:00+02:00", "start": "09:30", "end": "2026-07-20T10:00:00+02:00", "duration": "00:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-91167-unravelling-the-mystery-of-free-threading-for-scientific-computing", "url": "https://pretalx.com/euroscipy-2026/talk/37RGPY/", "title": "Unravelling the mystery of free threading for scientific computing", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "Python\u2019s Global Interpreter Lock (GIL) has long been a barrier for scientific computing, limiting the ability to fully utilise multi-core hardware and scale parallel workloads. With the introduction of free-threaded Python (PEP 703), this constraint is finally being lifted. Several core scientific Python packages (including NumPy, SciPy, and pandas) have already begun transitioning to support users who wish to use free-threading, paving the way for improved performance and concurrency for the broader ecosystem. This talk will explore what free-threading means for the scientific Python community,  discuss the technical challenges in adopting this new paradigm, and highlight the practical impact it can have for users and maintainers. Attendees will receive actionable guidance for leveraging free-threading in their projects, including insights into the transition process and lessons learned from early adopters.", "description": "## Target Audience\n* Python users in scientific computing (researchers, engineers, data scientists)\n* Open source package maintainers and contributors considering adopting free threading\n*Developers interested in Python performance and concurrency\n\n## What Attendees Will Learn\n* How free-threaded Python (PEP 703) changes concurrency and impacts scientific workloads\n* Which major packages currently support free-threading and latest updates\n* Practical tips and best practices for adopting free-threading in projects\n*Tools and resources to help transition codebases for the new paradigm\n\n## Outline:\n**1. Introduction: Why Free Threading Matters for Scientific Python (5 min)**\n* The GIL\u2019s impact on scientific computing and parallel workloads\n\n**2. What Is Free-Threaded Python? (5 min)**\n* Overview of PEP 703 and Python 3.14t\n* Difference between multi processing and threading\n\n**3. How is the ecosystem adapting? (10 min)**\n* Status update: which packages currently support free-threading (NumPy, SciPy, pandas, etc.)\n* Early experiences from package developers and the community\n* Share data on performance gains from transition to free threading\n* Note to reviewer: this work is ongoing, so will have more detail to include here over the next few months\n\n**5. Lessons Learned and Best Practices (10 min)**\n* Practical tips for users: how to take advantage of free-threading in your code\n* Share some case studies from OSS projects that have begun adopting FTP, describe technical hurdles faced\n* Some tools / resources that can help you with the transition", "recording_license": "", "do_not_record": false, "persons": [{"code": "KCK9JM", "name": "Thomas Wouters", "avatar": null, "biography": null, "public_name": "Thomas Wouters", "guid": "2a9d4ed7-3d80-569f-9896-60c10dca3f76", "url": "https://pretalx.com/euroscipy-2026/speaker/KCK9JM/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/37RGPY/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/37RGPY/", "attachments": []}, {"guid": "9e634dec-3e4f-5d09-8a96-96f1da54aba2", "code": "8DKJ7N", "id": 98498, "logo": null, "date": "2026-07-20T10:10:00+02:00", "start": "10:10", "end": "2026-07-20T11:10:00+02:00", "duration": "01:00", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-98498-from-theory-to-practice-how-python-enabled-modern-astronomical-data-analysis", "url": "https://pretalx.com/euroscipy-2026/talk/8DKJ7N/", "title": "From theory to practice: how Python enabled modern astronomical data analysis", "subtitle": "", "track": "Physical Sciences and Engineering", "type": "Keynote", "language": "en", "abstract": "The intrinsic difficulties related to gathering and processing astronomical data have traditionally branded it a \u201cdata starving\u201d field. The situation changed only in the last few decades with the advent of large scale sky surveys that made publicly available the first extremely large and coherent astronomical data sets. In this context, Python has played a crucial role in enabling an extremely fast development of tools among the astronomical community, thus fostering an unprecedented revolution on how experts interact with their data. In this talk, I will describe the first stages of astronomical data analysis, how new data challenges were imposed in the last century and how Python was crucial to change the paradigm of astronomical data analysis. Finally, I will discuss the new framework of astronomical data and the impact of python developed tools in the process of scientific analysis. Finally, I will highlight the most challenging issues still to be faced in the era of the surveys like the Vera C. Rubin Observatory, as well as the impact of foundation models in the scientific exercise of astronomical discovery.", "description": "Invited Keynote talk.\nThe 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?", "recording_license": "", "do_not_record": false, "persons": [{"code": "MUARB8", "name": "Emille Ishida", "avatar": null, "biography": "Research engineer at CNRS, France. Co-PI of the Fink Broker and co-founder of the SNAD collaboration and the Cosmostatistics Initiative (COIN). Work on the development of interdisciplinary science environments, machine learning applications to astronomy and adaptive learning techniques.", "public_name": "Emille Ishida", "guid": "00d64ab1-cb09-5b48-812e-b648190aaffb", "url": "https://pretalx.com/euroscipy-2026/speaker/MUARB8/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/8DKJ7N/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/8DKJ7N/", "attachments": []}, {"guid": "1f9d2c4a-c2ea-5de4-a4dc-248bbf07425d", "code": "G3SRPL", "id": 90384, "logo": null, "date": "2026-07-20T11:30:00+02:00", "start": "11:30", "end": "2026-07-20T12:00:00+02:00", "duration": "00:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-90384-python-tile-programming-for-gpus", "url": "https://pretalx.com/euroscipy-2026/talk/G3SRPL/", "title": "Python Tile Programming for GPUs", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "Parallel programming can be intimidating, but doesn\u2019t need to be! Tile-based programming models make GPU parallelism more newcomer-friendly, highly productive, and still fast by letting you write sequential, array-centric code while the framework handles parallelization, synchronization, and data movement.\n\nIn this example-driven talk, we\u2019ll introduce tile-based programming in Python using NVIDIA\u2019s new stack: [cuTile](https://github.com/NVIDIA/cutile-python) and its compiler foundation, [Tile IR](https://github.com/NVIDIA/cuda-tile). You\u2019ll see recently announced CUDA Tile capabilities in action, including multi-GPU communication, interoperability with traditional CUDA SIMT, and support for more diverse kernels such as convolutions and stencils. We\u2019ll compare tile and SIMT approaches, build intuition for performance and execution, and demonstrate practical debugging and reasoning techniques. Along the way, you\u2019ll see real workloads: HPC stencils, an SPMV plus CG solver, and ML models from [TileGym](https://github.com/NVIDIA/TileGym). You\u2019ll leave with a clear sense of when tile programming helps, and how it enables more portable high-performance Python as hardware trends evolve.", "description": "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. \n\nTile 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.\n\nIn 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).\n\nTile programming aligns well with SciPy's array-centric ethos and has roots in older HPC libraries, such as [NWChem\u2019s 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.\n\nIn this talk, you'll:\n- Learn the best practices for writing tile-based Python applications for GPUs.\n- Gain insight into the performance of tile GPU code and how it actually gets executed.\n- Discover how to reason about and debug tile code in Python applications.\n- Understand the differences between tile and SIMT programming and when each paradigm should be used.\n- See how tile programming makes your software portable in light of recent hardware trends.\n\nBy 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "VKG8RE", "name": "Bryce Adelstein Lelbach", "avatar": null, "biography": "Bryce Adelstein Lelbach has spent over a decade developing programming languages, compilers, and libraries. He is passionate about parallel programming and strives to make it more accessible for everyone.\n\nBryce is a Principal Architect at NVIDIA, where he founded the Core C++ Compute Libraries team and now leads the Vanguard Programming group that drives NVIDIA's roadmap for programming languages, compilers, and core libraries.\n\nHe is a leader of the systems programming language community, having served as chair of the C++ Library Evolution and the US programming language standards committee. He has been an organizer and program chair for many conferences over the years. On the C++ committee, he has worked on concurrency primitives, parallel algorithms, senders, and multidimensional arrays.\n\nHe previously worked at Lawrence Berkeley National Laboratory and Louisiana State University. He is one of the founding developers of the HPX parallel runtime system. \n\nOutside of work, Bryce is passionate about airplanes and watches. He lives in Midtown Manhattan with his girlfriend and dog.", "public_name": "Bryce Adelstein Lelbach", "guid": "2d0de9a8-9373-5b37-85ce-a11d6e0bef3d", "url": "https://pretalx.com/euroscipy-2026/speaker/VKG8RE/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/G3SRPL/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/G3SRPL/", "attachments": []}, {"guid": "a6f841ca-de98-5df2-89f3-dc02b40c05be", "code": "JEZYYU", "id": 92303, "logo": null, "date": "2026-07-20T12:10:00+02:00", "start": "12:10", "end": "2026-07-20T12:30:00+02:00", "duration": "00:20", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-92303-ctrl-alt-contribute-bringing-open-source-into-the-classroom", "url": "https://pretalx.com/euroscipy-2026/talk/JEZYYU/", "title": "Ctrl + Alt + Contribute: Bringing Open Source into the Classroom", "subtitle": "", "track": "Community, Education, and Outreach", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "In Fall 2025, the UConn School of Mechanical, Aerospace, and Manufacturing Engineering launched Open Source Experiences, an elective course developed in partnership with six NumFOCUS-supported projects (napari, BiocPy, Blosc, MNE-Python, mlpack, JuliaHub). The course embedded students directly into active open source communities, where they contributed to the codebases, collaborated with project maintainers, and learned about community-driven open source software development. In this talk, we will share the lessons learned from piloting this collaboration model, and how these experiences benefit students, open source and open science communities, and educators alike. Attendees will take away actionable insights for integrating open source contributions into their own classrooms and programs.", "description": "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.\n\nIn 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.\n\nStudent 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.\n\n**Talk outline:**\n\n- Course design and goals: balancing academic learning objectives with community needs, assessment strategies.\n- Collaboration with maintainers: selecting projects, preparing onboarding documentation, setting expectations, and creating a mentorship model that respects both students\u2019 learning and maintainer time.\n- Student outcomes: reflections on learning gains around technical skills, professional communication, and confidence engaging in open source ecosystems.\n- Challenges and lessons learned.\n\nWe\u2019ll also share examples of student contributions and how they augmented both the ecosystem and the students\u2019 portfolios.\n\nWhether you\u2019re 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\u2019s contributor pipeline, this talk will give you concrete ideas to adapt.", "recording_license": "", "do_not_record": false, "persons": [{"code": "CNPJSM", "name": "Inessa Pawson", "avatar": null, "biography": "Inessa is building bridges between people, open source software, and open science. Over the years, she has launched and continues to support several educational initiatives focused on widening the open source contributor pipeline. Inessa is Director of Open Source Program Office at OpenTeams and guest faculty at University of Connecticut. She also serves on the NumPy Steering Council, Scientific Python Ecosystem Coordination Steering Committee, and the pyOpenSci Advisory Council. Inessa is perpetually fascinated by incentive design, collaborative intelligence, and jazz.", "public_name": "Inessa Pawson", "guid": "66a47ef5-755d-58fc-97e5-9c1956817aac", "url": "https://pretalx.com/euroscipy-2026/speaker/CNPJSM/"}, {"code": "BNMRNB", "name": "Ryan C Cooper", "avatar": null, "biography": "Ryan C. Cooper is an Associate Professor-in-Residence at the University of Connecticut. His background is in mechanics and materials science with an emphasis on numerical simulations and engineering education. He has been using Jupyter and GitHub to enhance the classroom experience for over six years. Prof. Cooper has developed and free open source materials for computational work in engineering and volunteered with the NumPy documentation team SciPy track chair. Ryan is an integral part of the AI in the School of Engineering committee. He has a Ph.D. from Columbia University and spent two and a half years at Oak Ridge National Laboratory as a Postdoctoral researcher.", "public_name": "Ryan C Cooper", "guid": "52d6720e-6c1c-5399-a4f8-4acc29c8fb8d", "url": "https://pretalx.com/euroscipy-2026/speaker/BNMRNB/"}, {"code": "DMRAK7", "name": "Ryan Curtin", "avatar": null, "biography": "Dr. Ryan Curtin is an independent researcher and open-source software developer, leading the development and maintenance of several packages in the C++ scientific software ecosystem.  During his Ph.D. at Georgia Tech he focused on the formalization of dual-tree algorithms, a class of geometric branch-and-bound algorithms that can be used to solve subproblems relevant to machine learning techniques.  These algorithms underlie the efficient mlpack C++ machine learning library, which he has\nled since 2010.  In his free time, he races go-karts, so he never escapes from trying to go fast in one way or another.", "public_name": "Ryan Curtin", "guid": "77d237cd-528d-53e8-9cd3-a439b14ff2c8", "url": "https://pretalx.com/euroscipy-2026/speaker/DMRAK7/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/JEZYYU/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/JEZYYU/", "attachments": []}, {"guid": "f610c43c-a979-5cb3-aba9-c49c8b77b4df", "code": "ZDBNXL", "id": 92015, "logo": null, "date": "2026-07-20T14:00:00+02:00", "start": "14:00", "end": "2026-07-20T14:20:00+02:00", "duration": "00:20", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-92015-disentangling-cosmology-from-astrophysics-with-gaussian-process-emulation-and-likelihood-free-inference", "url": "https://pretalx.com/euroscipy-2026/talk/ZDBNXL/", "title": "Disentangling Cosmology from Astrophysics with Gaussian Process Emulation and Likelihood-Free Inference", "subtitle": "", "track": "Physical Sciences and Engineering", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "Galaxy clusters are the largest gravitationally bound structures in the universe, shaped by both the overall composition of the cosmos and the complex physics of the gas within them. Disentangling these two influences is a central challenge in modern astrophysics, and key to resolving cases where different experiments measuring the same fundamental properties of the universe yield conflicting results, pointing to new physics.\n\nTelescopes such as eROSITA, the Simons Observatory, CMB-S4, Euclid, and the Rubin Observatory are now observing clusters across multiple wavelengths at unprecedented depth, making this challenge urgent and tractable.\n\nWe present a likelihood-free inference framework combining Gaussian process emulation (CARPoolGP) with neural networks to jointly infer 28 cosmological and astrophysical parameters from stacked cluster profiles. The emulator, trained on 768 hydrodynamic zoom-in simulations (CAMELS-zoomGZ), generates low-variance predictions across the full parameter space. Neural networks, optimized via Optuna, map emulated multiwavelength profiles to posterior moments.\n\nWe achieve correlation coefficients above 0.97 for all cosmological parameters and above 0.90 for all astrophysical ones, with robustness to realistic noise levels. This accuracy across a full 28-dimensional parameter space is unprecedented, allowing us to separate cosmology from internal cluster physics, enabling more reliable cosmological measurements and better-calibrated simulations.", "description": "**Summary:**\n 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).\n\n\n**Detailed Description**\n\n\n**1. Motivation and Scientific Context**\n\nGalaxy 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).\n\nIn 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.\n\nThis 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.\n\n**2. Simulation Suite and Gaussian Process Emulation**\n\nOur 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.\n\nSince 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.\n\nFrom 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.\n\n**3. Neural Network Pipeline**\n\nThe 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.\n\nThe 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.\n\nThe pipeline is implemented in Python:\n\n- **PyTorch** for model definition, training, and GPU-accelerated inference. The architecture is modular, with layers, neurons, and dropout as hyperparameters.\n- **Optuna** for Bayesian hyperparameter optimization via Tree-Structured Parzen Estimation, running 1,000+ trials per experiment optimizing architecture, learning rate, weight decay, and dropout.\n- **NumPy/SciPy** for all data preprocessing: profile extraction, concatenation, normalization, noise injection, radial cuts, and Sobol sequence sampling.\n- **Matplotlib** for all visualizations including radar charts, bar charts, and predicted-vs-true plots.\n\nTraining 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.\n\n**4. Key Results**\n\nWith 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.\n\nWe 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.\n\n**5. Robustness Analyses**\n\nWe conducted four systematic studies to stress-test the results:\n\n*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.\n\n*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.\n\n*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.\n\n*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.\n\n**7. Relevance to the EuroSciPy Community**\n\nThis 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "78CTAH", "name": "Elena Hernandez-Martinez", "avatar": null, "biography": "Elena Hernandez Martinez is an AI Researcher at the appliedAI Institute for Europe (TransferLab). She holds a Ph.D. from LMU Munich, where she worked on cosmological simulations of large-scale structure formation in the Computational Astrophysics Research Group. During a research stay at the Flatiron Institute (Simons Foundation), she developed machine learning methods for cosmological parameter inference from galaxy cluster data. Her interests span simulation-based inference, neural networks for scientific applications, and high-performance computing.", "public_name": "Elena Hernandez-Martinez", "guid": "5ff09194-fe8d-583c-8096-62d6e4989bf6", "url": "https://pretalx.com/euroscipy-2026/speaker/78CTAH/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/ZDBNXL/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/ZDBNXL/", "attachments": []}, {"guid": "fe667e90-e715-5614-8ef4-b6879200dd7b", "code": "VXRSM8", "id": 91344, "logo": null, "date": "2026-07-20T14:30:00+02:00", "start": "14:30", "end": "2026-07-20T15:00:00+02:00", "duration": "00:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-91344-scikit-learn-s-metadata-routing-api", "url": "https://pretalx.com/euroscipy-2026/talk/VXRSM8/", "title": "Scikit-learn's Metadata Routing API", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "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.\n\nWe 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.\n\nUsing 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.\n\nAttendees 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.", "description": "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.\n\nWe 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.\n\nUsing 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.\n\nAttendees 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "MUW3K7", "name": "Stefanie Senger", "avatar": null, "biography": "Stefanie is an open-source developer and maintainer of scikit-learn, contributing also to related libraries. She trained and taught at LeWagon (2022\u20132023), interned with scikit-learn (2023), and worked at muffintech (2023) before joining probabl\u2019s open-source team in 2024. She holds a PhD in History from the University of Potsdam (2021) and was active on Wikipedia as a writer and mentor (2011\u20132014).", "public_name": "Stefanie Senger", "guid": "f349211c-4c2d-5736-b9eb-30353418d1c3", "url": "https://pretalx.com/euroscipy-2026/speaker/MUW3K7/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/VXRSM8/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/VXRSM8/", "attachments": []}, {"guid": "b67bf3de-8805-59c7-9549-8945332362f8", "code": "VPYLDF", "id": 91684, "logo": null, "date": "2026-07-20T15:20:00+02:00", "start": "15:20", "end": "2026-07-20T15:40:00+02:00", "duration": "00:20", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-91684-profiling-python-gpu-code", "url": "https://pretalx.com/euroscipy-2026/talk/VPYLDF/", "title": "Profiling Python GPU Code", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "Your GPU is fast, so why does your Python code still feel slow? This talk shows a practical, Python-first profiling workflow with Nsight Systems, Nsight Compute, and NVTX for CuPy, Numba, PyTorch, JAX, and CUDA extensions. We will use timelines to find launch overhead, hidden synchronizations, and host-device copies, then drill into kernel bottlenecks like memory throughput and occupancy. You will leave with a repeatable loop for turning profiles into measurable speedups.", "description": "Your GPU is fast, so why does your Python code still feel slow?\n\nWhen 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.\n\nIn 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.\n\nKey takeaways:\n- How to use NVTX ranges and markers from Python to make timelines explain themselves.\n- How to capture the right Nsight Systems trace to spot launch overhead, sync points, copies, and stream issues.\n- How to pivot from a timeline hotspot to Nsight Compute and choose metrics that actually answer your question.\n- How to interpret common kernel bottlenecks (memory throughput, occupancy limits, instruction mix) without drowning in counters.\n- A checklist for avoiding profiling traps (implicit sync, warmup, clock variability, sampling noise, and \"profiling changed my code\").\n- A repeatable workflow you can apply to real Python GPU stacks, from single kernels to end-to-end pipelines.\n\nBy 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "VKG8RE", "name": "Bryce Adelstein Lelbach", "avatar": null, "biography": "Bryce Adelstein Lelbach has spent over a decade developing programming languages, compilers, and libraries. He is passionate about parallel programming and strives to make it more accessible for everyone.\n\nBryce is a Principal Architect at NVIDIA, where he founded the Core C++ Compute Libraries team and now leads the Vanguard Programming group that drives NVIDIA's roadmap for programming languages, compilers, and core libraries.\n\nHe is a leader of the systems programming language community, having served as chair of the C++ Library Evolution and the US programming language standards committee. He has been an organizer and program chair for many conferences over the years. On the C++ committee, he has worked on concurrency primitives, parallel algorithms, senders, and multidimensional arrays.\n\nHe previously worked at Lawrence Berkeley National Laboratory and Louisiana State University. He is one of the founding developers of the HPX parallel runtime system. \n\nOutside of work, Bryce is passionate about airplanes and watches. He lives in Midtown Manhattan with his girlfriend and dog.", "public_name": "Bryce Adelstein Lelbach", "guid": "2d0de9a8-9373-5b37-85ce-a11d6e0bef3d", "url": "https://pretalx.com/euroscipy-2026/speaker/VKG8RE/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/VPYLDF/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/VPYLDF/", "attachments": []}, {"guid": "d5a6e992-6d4d-565e-8257-4b1b1f914035", "code": "8T33ZK", "id": 92206, "logo": null, "date": "2026-07-20T16:00:00+02:00", "start": "16:00", "end": "2026-07-20T16:30:00+02:00", "duration": "00:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-92206-from-code-to-app-how-to-ship-your-tool-to-your-non-programming-collaborators", "url": "https://pretalx.com/euroscipy-2026/talk/8T33ZK/", "title": "From Code to app, how to ship your tool to your non programming collaborators", "subtitle": "", "track": "Interdisciplinary Frontiers and other Scientific Python Applications", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "When writing Python code for scientific applications, you may reach a point where you want to share your work with collaborators that don't code. But what if you do not want to require them to set up Python environments or act as their tech support?\n\nThere are tools to avoid that by converting your Python code into executable that can be run without Python setup, and with all dependencies included.\nIn this talk I will share my experience with using some of those tools like PyInstaller and Conda constructor and how you could do the same. \nShowed solutions might be used for both CLI script and application with graphical Interface.\nImportantly, I will also mention some of the callenges that you might encounter and how to solve them.", "description": "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.\nBased 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.\nThese two tools are used as they represent two different approaches:\n1) 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 \n2) 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.\n\nThe presentation will include simple examples of how to use these tools, and also some tips on how to automate the process using CI.\nThere will also be a part about problems that you might encounter, like signing of executables and why it might be important. \nArmed 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!\"", "recording_license": "", "do_not_record": false, "persons": [{"code": "7V3CXP", "name": "Grzegorz Bokota", "avatar": null, "biography": "I'm napari (napari.org) core team member and Assistant Professor on University of Warsaw, \n\nMy background are Math and Computer Science. \nAs a daily task in napari project I focus on debug edge case, improving code efficiency and API to allow user focus on solving problems, not reinventing wheels.", "public_name": "Grzegorz Bokota", "guid": "0408dba1-0163-5e43-9c22-deada65e8fd2", "url": "https://pretalx.com/euroscipy-2026/speaker/7V3CXP/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/8T33ZK/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/8T33ZK/", "attachments": []}], "Room 1.19 (Ground Floor, Shannon)": [{"guid": "916aa82f-f864-5bf8-b197-1649d3949383", "code": "PXGC9R", "id": 91367, "logo": null, "date": "2026-07-20T09:30:00+02:00", "start": "09:30", "end": "2026-07-20T10:00:00+02:00", "duration": "00:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-91367-parallel-reactive-groundwater-transport-modeling", "url": "https://pretalx.com/euroscipy-2026/talk/PXGC9R/", "title": "Parallel Reactive Groundwater Transport Modeling", "subtitle": "", "track": "Environmental and Earth Sciences", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "Contaminated groundwater often carries multiple dissolved chemical species that react with each other, potentially causing mineral precipitation and altering subsurface flow properties. Simulating these coupled processes requires modeling groundwater flow, multi-species solute transport, and geochemical reactions simultaneously. This talk presents rtmf6, a new open-source reactive transport model that couples MODFLOW 6 (groundwater flow and transport) with PHREEQC 3 (geochemical reactions) through the Python libraries pymf6 and PhreeqPy. A key design goal was parallelization: species transport runs as independent parallel processes, while geochemical computations use multi-threading. Benchmark results show good agreement with the established model PHT3D, while rtmf6 supports a substantially broader range of applications by leveraging the full capabilities of MODFLOW 6.", "description": "Contaminated groundwater often carries multiple dissolved chemical species that can react with each other. These reactions may cause mineral precipitation \u2014 the formation of solid phases from dissolved substances \u2014 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 \u2014 where positively charged ions in solution swap with ions bound to mineral surfaces \u2014 can further alter dissolved species concentrations.\n\nNumerical 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.\n\nMODFLOW 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.\n\nThe 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 \u2014 a PHREEQC variant specifically designed for coupling with transport models. PhreeqcRM exposes a comprehensive API that enables programmatic control over all geochemical modeling capabilities.\n\nThe 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.\n\nStarting 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.\n\nThe 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.\n\nBenchmark 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "9KSJ3K", "name": "Mike M\u00fcller", "avatar": null, "biography": "Dr. Mike M\u00fcller has been working with Python since 1999 and teaching it professionally since 2004. As a trainer at Python Academy (https://www.python-academy.com), he has taught over 580 Python courses totaling more than 1,400 teaching days to thousands of participants worldwide.\n\nMike has taught more than 75 tutorials at Python conferences, including 29 tutorials at PyCon US over the years. He is known for his hands-on teaching approach, live coding demonstrations, and comprehensive course materials that participants can use as references long after the tutorial ends. His tutorials blend practical examples with solid theoretical foundations, making complex topics accessible and immediately applicable.\n\nBeyond teaching, Mike is deeply involved in the Python community. He has organized conferences including PyCon DE, EuroSciPy, and numerous BarCamps. His contributions to the community have been recognized with the PSF Community Service Award and PSF Fellow status. He serves as chair of the German Python Software Verband.\n\nMike holds a doctorate in hydrology and brings a scientific perspective to programming education. He believes in learning by doing and creates supportive environments where participants feel comfortable asking questions and experimenting with code.\n\n# Dr. Mike M\u00fcller\n\n## Education\n\n- German Diplom-Ingenieur Wasserwirtschaft (5 years) at University of\n  Technology Dresden,\n  Germany -- Wasserwirtschaft literal translation water management, engineering\n  degree in water resources management with focus on groundwater hydrology and\n  modelling\n- MS in Hydrology and Water Resources at University of Arizona, Tucson, USA\n- Ph.D. in Mining Hydrology at BTU Cottbus, Germany -- Development of a coupled\n  surface water and groundwater model for open pit mine lakes (PITLAKQ)\n\n## Work Experience\n\n- Combination of hydrology and software development\n- Coupling of models\n- Python teaching -- since 2004, >1500 full teaching days with focus on scientist and engineers\n\n## Model Coupling\n\nI have experience in coupling different hydrological and hydraulic models, such as:\n\n### PITLAKQ\n\nThis is my Ph.D. work that couples a finite volume groundwater model (PCGEOFIM),\na hydrodynamic and water quality lake Model (CE-QUAL-W2), and a\nhydro-geo-chemical model (PHREEQC).\n[PITLAKQ](\"https://www.pitlakq.com/\") is open source.\nIt has been applied world wide.\nI used it for pit lakes in Germany, Australia, and Canada.\nOthers have used it in many other countries of the world.\n\n### Coupling of a river flood model and a groundwater model\n\nI have been involved in a research project that couples a river model, a sewer\npipeline model and groundwater model for the river Elbe in the city of Dresden,\nGermany.\nI was responsible for the coupling of the river model and the groundwater\nmodel.\n\n### Rainfall runoff model -- groundwater model\n\nI implemented a coupling of a rainfall runoff model (ArcEGMO) and a groundwater\nmodel (PCGEOFIM) for a watershed in Germany.\n\n### Density-driven flow in groundwater and lake\n\nI coupled a density-driven groundwater flow and transport model (MODMST) to\nPITLAKQ.\nThis was used for a long-term simulation of a sub-aquatic landfill,\ni.e. a lake over a deposit of mining waste.\n\n###  MODFLOW with dynamic boundary conditions - pymf6\n\nI am the developer of [pymf6](\"https://pymf6.readthedocs.io/en/latest/\")\nthat allows to interact with MODFLOW 6 via Python at runtime.\nThis can be used to implement dynamic boundary conditions.\nExamples are:\n\n- water-level-controlled wells that dynamically adjust their pumping rates\n  based  on simulated water levels in the aquifer\n- dynamic values of the resistance of the colmation layer at the river bottom\n  that depend on the flow direction between river and aquifer\n- technical heat boundary conditions in urban settings such as building\n  basements and tunnels\n\n### MODFLOW 6 with AEM\n\nI coupled an Analytic Element Model (AEM)\n[TTim](\"https://ttim.readthedocs.io/en/stable/index.html\") with MODFLOW 6\nvia [pymf6](\"https://pymf6.readthedocs.io/en/latest/\").\nThis allows to combine the grid-based approach of MODFLOW with the analytic,\ngrid-less approach of AEMs.\n\n### MODFLOW 6 with PHREEQC -- rtmf6\n\nI coupled MODFLOW 6 with the geochemical model PHREEQC via\n[PhreeqPy](\"https://www.phreeqpy.com/\")using\n[PhreeqcRM](\"http://github.com/usgs-coupled/phreeqcrm\").\nI am the author of PhreeqPy.\nThe result is [rtmf6](\"https://www.rtmf6.com/\").", "public_name": "Mike M\u00fcller", "guid": "83509971-e18d-5ad6-843b-373fc98d3359", "url": "https://pretalx.com/euroscipy-2026/speaker/9KSJ3K/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/PXGC9R/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/PXGC9R/", "attachments": []}, {"guid": "af6b680c-dc3b-5398-9abc-e4c3f6fc420b", "code": "EALXXJ", "id": 92201, "logo": null, "date": "2026-07-20T11:30:00+02:00", "start": "11:30", "end": "2026-07-20T12:00:00+02:00", "duration": "00:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-92201-re-connecting-foundational-libraries-with-their-communities-successes-failures-and-surprises-in-building-the-napari-plugin-sustainability-initiative", "url": "https://pretalx.com/euroscipy-2026/talk/EALXXJ/", "title": "(Re)-connecting foundational libraries with their communities: Successes, failures, and surprises in building the napari plugin sustainability initiative", "subtitle": "", "track": "Community, Education, and Outreach", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "Foundational Python libraries provide critical functionality that diverse communities of downstream developers and users depend on, yet the teams maintaining these libraries must make hard choices about where to spend limited resources. Often, gaps in awareness between a core project and its broader community silently erode trust, collaboration, and sustainability. This talk shares lessons from a community-driven sustainability initiative to (re)-connect napari\u2014a foundational library for interactive, multi-dimensional image and data viewing built on the scientific Python stack\u2014with its ecosystem of over 580 community-developed plugins. Napari plugins are built and used by scientists, from complete Python novices to cutting-edge code experts, from the biological to physical to social sciences, and beyond. Through a working group that brought together the napari core team, plugin developers and end users, the plugin sustainability initiative discovered that new avenues for communication and collaboration lead to shared ownership of the ecosystem's progress. This talk will discuss what engagement approaches worked, what has not worked, what surprised us, and what any Python project with downstream developers can take away about sustainably growing and maintaining a community and its software ecosystem.", "description": "Many scientific Python projects follow a familiar arc: early excitement, rapid adoption, a burst of community-built extensions\u2014and 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.\n\nIn 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\u2014novice to experienced\u2014across 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.\n\nThe 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\u2014from a service relationship to shared ownership\u2014has 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.\n\nThe 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.\n\n**1. A combined automated and human review system** emerged as the highest-impact focus. We're building automated tooling\u2014inspired by [SciPy's repo-review](https://repo-review.readthedocs.io/en/latest/)\u2014that 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.\n\n**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\u2014tested combinations that install together cleanly\u2014to directly address the dependency hell that drives users away.\n\n**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.\n\nThese 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "TEUNCZ", "name": "Tim Monko", "avatar": null, "biography": "I am a full-time maintainer and community manager of napari, an interactive multi-dimensional Python image and data viewer, and its plugin ecosystem. I work to extend the plugin ecosystem and help scientists achieve their goals with image analysis.", "public_name": "Tim Monko", "guid": "6e7a85e7-db43-5cee-a74a-aa6865f5e5ea", "url": "https://pretalx.com/euroscipy-2026/speaker/TEUNCZ/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/EALXXJ/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/EALXXJ/", "attachments": []}, {"guid": "dd998314-4530-5f43-a8b1-380d789e9d8d", "code": "PRCPUX", "id": 89807, "logo": null, "date": "2026-07-20T12:10:00+02:00", "start": "12:10", "end": "2026-07-20T12:30:00+02:00", "duration": "00:20", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-89807-building-a-scientific-taxonomy-at-scale-with-graph-clustering-embeddings-and-llms", "url": "https://pretalx.com/euroscipy-2026/talk/PRCPUX/", "title": "Building a Scientific Taxonomy at Scale with Graph Clustering, Embeddings, and LLMs", "subtitle": "", "track": "Applied AI & LLM Technologies and Use Cases", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "Scientific organizations struggle to extract actionable insights from publication data tagged with inconsistent and noisy keywords. Transforming hundreds of thousands of such keywords into a **110,000+ concept**, semantically consistent taxonomy, and attaching them hierarchically at scale, requires more than ad-hoc normalization: it demands careful system design.\n\nThis talk presents a production-grade pipeline that extends **OpenAlex's 4-level framework** (Domain \u2192 Field \u2192 Subfield \u2192 Topic) with a granular **Concept layer**, resulting in a **5-level scientific taxonomy**. The system combines **SPECTER2 embeddings** to model semantic similarity, **Leiden graph clustering** to group 100K+ concepts, and **Qdrant** for efficient vector-based hierarchical attachment.\n\nA central contribution is a strategic, multi-stage integration of **LLMs**. Rather than using LLMs end-to-end, we deploy them at **5 targeted points** where semantic judgment matters most: concept granularity filtering, field classification across **26 domains**, cluster renaming, explanation generation and validation of topic assignments using multi-embedding comparisons. Deterministic methods ensure scalability and reproducibility, while LLMs provide semantic precision where embeddings alone fall.\n\nThe resulting taxonomy is used in production to automatically tag **millions of publications**, enabling real-time trend detection and portfolio-level analytics that support strategic decision-making.", "description": "## The Problem\n\nLarge-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.\n\nThis talk presents a production system that transforms hundreds of thousands of raw keywords into a structured, semantically grounded taxonomy with over **110,000 concepts**.\n\n## Building a 5-Level Scientific Taxonomy\n\nWe extend OpenAlex's existing **4-level hierarchy** (Domain \u2192 Field \u2192 Subfield \u2192 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.\n\nTo 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.\n\n## Strategic Multi-Stage LLM Integration\n\nA 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:\n\n1. **Granularity Filtering** \u2013 Filtering candidate concepts to the appropriate Concept-level granularity, excluding terms that are too broad or too specific.\n2. **Field Classification** \u2013 Assigning concepts to one of **26 OpenAlex fields** in cases where embedding similarity alone is ambiguous.\n3. **Semantic Cluster Renaming** \u2013 Generating interpretable, human-readable labels for concept clusters.\n4. **Explanation Generation** \u2013 Producing concise semantic descriptions for each concept to support downstream validation and analytics.\n5. **Topic Assignment Validation** \u2013 Validating hierarchical attachment to Level-4 topics using a combination of multi-embedding similarity and LLM-based classification, with support for multi-label assignments.\n\nThis hybrid approach preserves scalability and reproducibility while leveraging LLMs for nuanced semantic decisions that deterministic methods struggle with.\n\n## Technical Infrastructure\n\n* **SPECTER2 embeddings** provide domain-aware semantic representations trained on scientific citation networks.\n* **Leiden clustering (igraph)** enables scalable community detection over large similarity graphs.\n* **Qdrant** supports efficient vector search for hierarchical attachment and large-scale similarity queries.\n* **Azure OpenAI** is used for structured LLM inference with prompt patterns designed for consistency and cost control.\n* A **validation framework** combines human review, automated consistency checks, and AI-assisted quality control before concepts are finalized.\n\n## Production Impact\n\nThe 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.\n\n## Key Takeaways\n\nAttendees will learn:\n\n* How to decide where LLMs add value in large-scale NLP pipelines\n* How to scale graph clustering to **100K+ nodes** in Python\n* Practical trade-offs between embeddings, graph methods, and LLMs\n* How to design hybrid embedding\u2013LLM architectures that balance cost, accuracy, and scalability\n* Validation strategies for correctness-sensitive semantic systems in production", "recording_license": "", "do_not_record": false, "persons": [{"code": "3U8HLG", "name": "Daniele Raimondi", "avatar": null, "biography": "Daniele is a data scientist with expertise in statistics, data science and AI, passionate about exploring the intersection of machine learning and financial markets. Since 2023, he is working at MDPI, one of the largest open-access publishers. A former national 400m sprinter.", "public_name": "Daniele Raimondi", "guid": "c7f80c08-2f1f-5dff-8d7b-c74fc8cd76d4", "url": "https://pretalx.com/euroscipy-2026/speaker/3U8HLG/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/PRCPUX/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/PRCPUX/", "attachments": []}, {"guid": "0891e4c2-c166-55f6-b498-f295f12afec0", "code": "QNGLCM", "id": 92026, "logo": null, "date": "2026-07-20T14:00:00+02:00", "start": "14:00", "end": "2026-07-20T14:20:00+02:00", "duration": "00:20", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-92026-linearoperator-stories-from-advancing-an-18-year-old-data-structure-in-scipy", "url": "https://pretalx.com/euroscipy-2026/talk/QNGLCM/", "title": "`LinearOperator`: stories from advancing an 18 year old data structure in SciPy", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "In this talk I share stories from the surprisingly challenging experience of modernising the `LinearOperator` data structure in SciPy to include support for batched input and alternative array types. Come and hear what it is like to learn the intricacies of an 18 year old data structure from scratch in order to be able to add new features without breaking the world!", "description": "[`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.\n\nThis 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.\n\nI'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.\n\nNo 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "MD3SSJ", "name": "Lucas Colley", "avatar": null, "biography": "I'm a core maintainer of [SciPy](https://scipy.org) and [Pixi](https://pixi.prefix.dev/latest/), and a member of [the Consortium for Python Data API Standards](https://data-apis.org). I recently finished a master's degree in Computer Science and Philosophy at the University of Oxford.", "public_name": "Lucas Colley", "guid": "970eabe7-7be2-5b31-ab0a-a0a6808b9a90", "url": "https://pretalx.com/euroscipy-2026/speaker/MD3SSJ/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/QNGLCM/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/QNGLCM/", "attachments": []}, {"guid": "26b27bd8-476e-51c4-89f1-6e9875ad72f7", "code": "UZQ3S3", "id": 90559, "logo": null, "date": "2026-07-20T14:30:00+02:00", "start": "14:30", "end": "2026-07-20T15:00:00+02:00", "duration": "00:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-90559-using-python-for-satellite-operations-lessons-from-the-mauve-space-mission", "url": "https://pretalx.com/euroscipy-2026/talk/UZQ3S3/", "title": "Using Python for satellite operations: Lessons from the Mauve Space Mission", "subtitle": "", "track": "Physical Sciences and Engineering", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "The Mauve Space Mission is a 16u smallsat, designed by Blue Skies Space, for studying stars in UV and visible wavelengths. It is a first of its kind private space mission, doing deep space observations. Mauve\u2019s primary method of pointing at its desired target is through two star trackers. However, the star trackers are not perfectly aligned with the telescope boresight which can cause the target to not be centred. Measurements from the detector can be used by on-board software to help correct this misalignment and keep the boresight focused on the target.\nThis talk will look at the role Python played in the development of some of Mauve\u2019s onboard software, from a proof of concept simulator through to the flight code currently operating in orbit. I will discuss the challenges during development, including constraints from the satellite manufacturers, and consider if Python is the right tool for onboard software.", "description": "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\u2019s 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.\nA proof-of-concept simulator was a crucial part of the development lifecycle of Mauve\u2019s onboard software. I will demonstrate the benefits of careful iteration in building confidence in PITL as a potential solution.\nI 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.\nThe 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.\nOverall 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "W9HQVP", "name": "Lawrence Bradley", "avatar": null, "biography": "Following an Integrated Masters in Mathematical Physics at the University of Edinburgh I joined Blue Skies Space Ltd. (BSSL) as a Software Engineer. During my time I have mostly worked on simulation tools, including orbital analysis software and instrument performance simulators. Over the past year I have developed on-board software for our first satellite Mauve.", "public_name": "Lawrence Bradley", "guid": "a1e738d5-cbf5-5ee7-902a-e83e0a32d4bb", "url": "https://pretalx.com/euroscipy-2026/speaker/W9HQVP/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/UZQ3S3/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/UZQ3S3/", "attachments": []}, {"guid": "57b5a2a8-3736-51c9-a65b-2c29737ee923", "code": "KFBJXK", "id": 90872, "logo": null, "date": "2026-07-20T15:20:00+02:00", "start": "15:20", "end": "2026-07-20T15:50:00+02:00", "duration": "00:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-90872-finding-the-right-ror-semantic-search-for-research-institutions", "url": "https://pretalx.com/euroscipy-2026/talk/KFBJXK/", "title": "Finding the Right ROR: Semantic Search for Research Institutions", "subtitle": "", "track": "Applied AI & LLM Technologies and Use Cases", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "Mapping freeform research affiliations to persistent identifiers such as [ROR (Research Organization Registry)](https://ror.org/)  is harder than it looks. Institution names appear in many forms such as abbreviations, alternate spellings, local languages, or legacy names, thus making a reliable mapping difficult to achieve at scale.\n\nIn this talk, we present a semantic retrieval pipeline that reframes institution identification as a search problem rather than a string-matching task. Our system combines named entity recognition to extract institution entities, dense embeddings to represent their semantic meaning, and vector search to retrieve the most likely ROR matches. This approach allows us to handle noisy, incomplete, and multilingual inputs while remaining resilient to variation in how institutions are referenced.\n\nBy treating institution matching as semantic retrieval, we improve recall and robustness without relying on heuristics or on a continuous expanding rule-based approach. The system scales naturally as new institutions are added and as naming conventions evolve, making it well suited for the dynamic research environment.\n\nWe will share implementation details, evaluation results, and practical lessons learned from deploying this pipeline in a real-world production setting.", "description": "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\u2019ve ever tried to map these freeform inputs to persistent identifiers like ROR, you know that simple string matching quickly falls apart.\n\nIn this talk, we\u2019ll look at institution matching from a different angle: treating it as a semantic retrieval problem instead of a normalization problem.\n\nI\u2019ll 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\u2019t just better accuracy, but to build a system that is maintainable as new institutions appear and naming conventions evolve.\n\nThis session focuses on real implementation experience, not just models. We\u2019ll cover architecture decisions, evaluation strategies, common failure cases, and trade-offs between rule-based and embedding-based approaches. You\u2019ll see what worked, what didn\u2019t, and what we learned from running this in production.\n\nIf you\u2019re working on entity resolution, search systems, metadata pipelines, or NLP in production, this talk will give you practical ideas you can reuse.", "recording_license": "", "do_not_record": false, "persons": [{"code": "MR8NT3", "name": "Diogo Rodrigues", "avatar": null, "biography": "Senior AI Engineer with 7+ years of experience architecting and deploying end-to-end ML solutions at scale. Specialized in NLP, Generative AI (LLM, RAG), Vector Search, and MLOps.", "public_name": "Diogo Rodrigues", "guid": "e13ad492-bb53-5ffb-9c36-0db8b9ca9966", "url": "https://pretalx.com/euroscipy-2026/speaker/MR8NT3/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/KFBJXK/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/KFBJXK/", "attachments": []}, {"guid": "67d65c8e-54d8-541d-86ab-9f0eb15d2cd6", "code": "CQHPYG", "id": 91135, "logo": null, "date": "2026-07-20T16:00:00+02:00", "start": "16:00", "end": "2026-07-20T16:30:00+02:00", "duration": "00:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-91135-rust-for-high-performance-computing-hpc-in-python", "url": "https://pretalx.com/euroscipy-2026/talk/CQHPYG/", "title": "Rust for High Performance Computing (HPC) in Python", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "Python has become the most widely used language in scientific computing and data science due to its approachable syntax, vast ecosystem of libraries, and rapid prototyping capabilities. However, its interpreted nature often poses a performance bottleneck for computationally intensive tasks common in High Performance Computing (HPC) used in scientific and data work, such as large-scale simulations, complex data analysis, and machine learning model training. \n\nEnhancing Python's performance, therefore, is critical for scientific computing: it allows researchers and engineers to maintain the productivity and flexibility of the Python environment while achieving the necessary speed and scalability to tackle demanding, real-world HPC problems without needing to switch to lower-level languages entirely.", "description": "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\u2019ll explore how Rust brings specific advantages to HPC, including guaranteed memory safety without garbage collection, zero-cost abstractions, and true parallelism.\n\nAttendees 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "8EGVC9", "name": "Cheuk Ting Ho", "avatar": null, "biography": "After having a career as a Data Scientist and Developer Advocate, Cheuk dedicated her work to the open-source community. Currently, she is working as a developer advocate for JetBrains. She has co-founded Humble Data, a beginner Python workshop that has been happening around the world. Cheuk also started and hosted a Python podcast, PyPodCats, which highlights the achievements of underrepresented members in the community. She has served the EuroPython Society board for two years and is now a fellow and director of the Python Software Foundation.", "public_name": "Cheuk Ting Ho", "guid": "6acb0b45-07a8-5f1c-a3fa-45ae8f0a9858", "url": "https://pretalx.com/euroscipy-2026/speaker/8EGVC9/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/CQHPYG/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/CQHPYG/", "attachments": []}], "Room 2.41 (First Floor, Turing)": [{"guid": "22e851f6-945d-572d-ba3d-bd720409ba1f", "code": "TENZMQ", "id": 90480, "logo": null, "date": "2026-07-20T14:00:00+02:00", "start": "14:00", "end": "2026-07-20T14:20:00+02:00", "duration": "00:20", "room": "Room 2.41 (First Floor, Turing)", "slug": "euroscipy-2026-90480-engineering-fortran-to-python-bindings-in-c-with-nanobind-json-and-cibuildwheel", "url": "https://pretalx.com/euroscipy-2026/talk/TENZMQ/", "title": "Engineering Fortran-to-Python Bindings in C++ with nanobind[_json] and cibuildwheel", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "In this talk, I will share some highlights from the development of the **PyPartMC** package (https://pypi.org/p/PyPartMC; https://pypi.org/project/PyPartMC) in which we have just celebrated our 100-th release!\n\n**PyPartMC** constitutes Python bindings to the **Fortran-implemented** internals of the **PartMC** aerosol dynamics Monte-Carlo simulation package developed at the University of Illinois Urbana-Champaign.\n\nRather than providing \"wrappers\" to highest-level PartMC interface, PyPartMC leverages the object-oriented architecture of PartMC and offers bindings to numerous datatypes and routines, as well as examples of how to construct simulation logic with these components in Python.\n\nApplications of PyPartMC concern **air-pollution** and **aerosol-cloud interactions** modelling, and range from **process studies** to **HPC applications** via coupling with Numerical Weather Prediction models. \n\nThe talk will be addressed primarily to **Python package developers**. I will share the lessons learned, some fun facts, and practical solutions which are applicable to any **Fortran-to-Python bindings** project.\n\nWe will go through the key design goals of the project: **maintainability**, **exposing internals**, **CI** and automation, complete **test coverage** and single-click operations on **Google Colab** and within **Matlab**.\n\nI will cover the encountered technical challenges - both solved and remaining - welcoming new contributors to the project.", "description": "## Detailed plan of the talk:\n### Intro\n- A short-summary of the **PartMC** package. \n- Outlining the requirements for a usable and maintainable Python interface\n- Quick overview of the project architecture in regards to the binding and packaging process\n\n### Challenges solved\n- 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!)\n- Codecov coverage for a 4-language codebase\n- Garbage collection of Fortran objects\n- Static linkage of **10+** git submodules, including some CMake trickery with undocumented CMake features!\n- Exposing C++ interface to Python through **nanobind**, including writing custom type casters\n- Internal JSON usage, which resulted in adopting an unmaintained **nanobind_json** codebase\n\n### Remaining challenges\n- Exception handling/propagation from C++ to C++ across Fortran layer (works only on selected platforms)\n- Eliminating (and type-checking) boilerplate glue code (Fortran+C), while retaining codecov functionality\n- The project is open-source! Contributions are welcome!\n\n### Highlights and benefits\n- 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**)\n- Coupling with other Python-implemented simulation components (e.g. packages simulating light scattering on particle populations)\n- Usage of PartMC via PyPartMC as a test-time dependency for other packages \n- Enabling access to PartMC from **Julia** and **Matlab** via respective Python bridges", "recording_license": "", "do_not_record": false, "persons": [{"code": "PG8YQL", "name": "Gracjan Adamus", "avatar": null, "biography": "Third-year **Applied Computer Science** student at **AGH** University of Krak\u00f3w. Interested in **GPUs**, **HPC** and **Open-source software**. Currently working as a **Summer Student** @ **[CERN](https://home.cern/)**.", "public_name": "Gracjan Adamus", "guid": "0a0e81aa-1264-5ee1-9a1b-f7bcbd5a4a39", "url": "https://pretalx.com/euroscipy-2026/speaker/PG8YQL/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/TENZMQ/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/TENZMQ/", "attachments": []}, {"guid": "fd21cc9a-3086-5cff-8b62-dae03887d215", "code": "BJLLHM", "id": 92216, "logo": null, "date": "2026-07-20T14:30:00+02:00", "start": "14:30", "end": "2026-07-20T15:00:00+02:00", "duration": "00:30", "room": "Room 2.41 (First Floor, Turing)", "slug": "euroscipy-2026-92216-usb-c-moment-for-ai-building-mcp-servers-with-fastmcp-and-python", "url": "https://pretalx.com/euroscipy-2026/talk/BJLLHM/", "title": "USB-C Moment for AI: Building MCP Servers with FastMCP and Python", "subtitle": "", "track": "Applied AI & LLM Technologies and Use Cases", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "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.", "description": "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.\n\nModel 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.\n\nWhat You'll Learn:\n- Hook & ContextThe cable chaos analogy. Why AI tool integration is broken today and what MCP fixes.\n- MCP in 4 MinutesProtocol anatomy: tools, resources, prompts. How the client\u2013server model works. Why Anthropic open-sourced it and who adopted it.\n- Live Build: Your First FastMCP ServerBlank file \u2192 working server in 20 lines. Decorators, type hints, auto-discovery. Connecting to Claude Desktop live on stage.\n- From Local to ProductionPackaging and deploying your server. Transport options: stdio vs. HTTP/SSE. Connecting to Claude Code in a real dev workflow.\n- Security & Anti-PatternsOAuth 2.1 authentication. Sandboxing and permission scoping. TLS configuration. The three anti-patterns that get MCP servers hacked.\n- Ecosystem & What's NextMCP registry, community servers, roadmap. Where Python fits in the broader MCP landscape.", "recording_license": "", "do_not_record": false, "persons": [{"code": "YY8U3E", "name": "Ruslan Korniichuk", "avatar": null, "biography": "Ukrainian Software and Platform Engineer based in Poland. Former Lead Engineer and Architect at Fortune 500 companies. Core areas: software development and cloud computing. Public speaker at EuroPython, PyCon CZ, PyCon LT, PyCon PL, Python Summit, Pytech Summit, and PyCode.", "public_name": "Ruslan Korniichuk", "guid": "781f30e3-c08e-550b-a069-0e878be288d7", "url": "https://pretalx.com/euroscipy-2026/speaker/YY8U3E/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/BJLLHM/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/BJLLHM/", "attachments": []}, {"guid": "41df6524-c0d3-5dfd-a653-38e8513cd61c", "code": "JUEQLF", "id": 92187, "logo": null, "date": "2026-07-20T15:20:00+02:00", "start": "15:20", "end": "2026-07-20T15:50:00+02:00", "duration": "00:30", "room": "Room 2.41 (First Floor, Turing)", "slug": "euroscipy-2026-92187-pure-functions-separate-i-o-functional-python-pipelines-for-reproducible-experiments", "url": "https://pretalx.com/euroscipy-2026/talk/JUEQLF/", "title": "Pure functions + Separate I/O: Functional Python Pipelines for Reproducible Experiments", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "Scaling data science pipelines in research and industry poses well-known maintainability challenges ([big ball of mud](https://www.laputan.org/pub/foote/mud.pdf)). Research codebases must support rapid iteration as insights evolve, while industry systems must scale amid changing business needs and organizational complexity. Effective projects should remain maintainable without overhauling the entire code base for each change. Ideally, evolving from a notebook experiment to a production-grade application should feel natural, with minimal overhead.\n\nIn this talk, we show how data science projects benefit from established software engineering principles, particularly those inspired by functional programming, in Python. The first part of the talk outlines the design principles. The second part, will go into our (brutally honest) insights from applying these in various research projects, spanning from master student experiments to the applications in our R&D teams.", "description": "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.\n\nWe 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.\n\nOur 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/).\n\nAttendees will leave with practical design principles for structuring data projects that scale naturally, from prototype to production, regardless of whether they adopt Ordeq itself.\n\n- Ordeq GitHub: https://github.com/ing-bank/ordeq\n- Ordeq documentation: https://ing-bank.github.io/ordeq/", "recording_license": "", "do_not_record": false, "persons": [{"code": "Y999YB", "name": "Niels Neerhoff", "avatar": null, "biography": "Niels is a software engineer at Palm, the AI treasury startup. Simon is a data scientist and engineer, currently working as tech lead at ING Bank. Both have experience at the intersection of software engineering and data science within the fintech domain.", "public_name": "Niels Neerhoff", "guid": "9bc74ba5-ba36-5802-bf68-b766f19b9847", "url": "https://pretalx.com/euroscipy-2026/speaker/Y999YB/"}, {"code": "FFGWSW", "name": "Simon Brugman", "avatar": null, "biography": "Simon has previously presented at SciPy 2022 ([popmon]([url](https://proceedings.scipy.org/articles/majora-212e5952-01d))) and EuroSciPy 2024 ([pycodehash](https://pycodehash.github.io/pycodehash/)). This year, we'll have a meta talk on \"Pure Functions + Separate I/O: Functional Python Pipelines for Reproducible Experiments\". Rather than going into the details of the framework itself, which we did at PyData Amsterdam 2025 ([ordeq](https://cfp.pydata.org/pydata-amsterdam-2025/talk/9WEFB3/)), we will provide our brutally honest learnings from applying this design pattern to actual research and development.\n\nSimon has actively developed various open-source projects, such as [pandas-profiling](https://github.com/Data-Centric-AI-Community/fg-data-profiling), and been an outside contributor to ruff and uv.\n\n- popmon: https://proceedings.scipy.org/articles/majora-212e5952-01d\n- pycodehash: https://pycodehash.github.io/pycodehash/\n- Ordeq at PyData Amsterdam: https://cfp.pydata.org/pydata-amsterdam-2025/talk/9WEFB3/\n- Ordeq code: https://github.com/ing-bank/ordeq\n- pandas-profiling: https://github.com/Data-Centric-AI-Community/fg-data-profiling", "public_name": "Simon Brugman", "guid": "c28031fe-19f0-5392-b230-4cac7d71a74d", "url": "https://pretalx.com/euroscipy-2026/speaker/FFGWSW/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/JUEQLF/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/JUEQLF/", "attachments": []}, {"guid": "86042f90-777a-53c5-9d75-1903c14a590d", "code": "SLDHUM", "id": 93007, "logo": null, "date": "2026-07-20T16:00:00+02:00", "start": "16:00", "end": "2026-07-20T16:30:00+02:00", "duration": "00:30", "room": "Room 2.41 (First Floor, Turing)", "slug": "euroscipy-2026-93007-towards-pythonic-custom-constraining-in-freecad-2d-drawing", "url": "https://pretalx.com/euroscipy-2026/talk/SLDHUM/", "title": "Towards Pythonic custom constraining in FreeCAD 2D drawing", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "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.", "description": "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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "7NP3WU", "name": "Ajinkya P Dahale", "avatar": null, "biography": "A mechanical engineer by training, I am now a software developer based in India, working as a project staff at IIT Bombay, Mumbai.\n\nI have been a contributor to FreeCAD since 2016, where my focus has been mostly in the 2D constrained drawing workbench \u201cSketcher\u201d, as well as the underlying solver \u201cplanegcs\u201d. In further detail, my interest has been in adding support for general curved geometry.", "public_name": "Ajinkya P Dahale", "guid": "cf1dac79-6bfd-578a-a3f6-35102ee1db8b", "url": "https://pretalx.com/euroscipy-2026/speaker/7NP3WU/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/SLDHUM/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/SLDHUM/", "attachments": []}]}}, {"index": 4, "date": "2026-07-21", "day_start": "2026-07-21T04:00:00+02:00", "day_end": "2026-07-22T03:59:00+02:00", "rooms": {"Room 1.38 (Ground Floor, Turing)": [{"guid": "b81c1e8c-3b67-547b-84de-a029b5266cc2", "code": "MLEJZS", "id": 91927, "logo": null, "date": "2026-07-21T09:30:00+02:00", "start": "09:30", "end": "2026-07-21T10:00:00+02:00", "duration": "00:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-91927-how-to-use-skrub-data-ops-in-practice", "url": "https://pretalx.com/euroscipy-2026/talk/MLEJZS/", "title": "How to use skrub Data Ops in practice", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "Skrub is a package that eases preparing dataframes so they can be used in machine-learning tasks. In practice, data can be spread over multiple tables, represent various types of information (tabular, textual, graphical), or be stored on external database systems rather than dataframes. \n\nSkrub Data Ops help with constructing versatile pipelines that can handle this variety of scenarios, while at the same time avoiding data leakage and allowing to build rich hyper-parameter grids that can be explored to maximize the performance of the final machine learning model. \n\nIn this talk, we give a brief introduction of the Data Ops framework before presenting three separate use cases highlighting their versatility: a traditional machine learning pipeline that uses Optuna to perform hyper-parameter tuning, a pipeline that trains on data stored in a relational database rather than a dataframe, and an image classification task with Pytorch. \n\nBy the end of the talk, attendees will learn about the skrub Data Ops,  their main features and how they can be used successfully in different practical scenarios.", "description": "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. \n\nSkrub 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.\n\nThrough 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. \n\nAll material  for the talk will be made available online.", "recording_license": "", "do_not_record": false, "persons": [{"code": "MJKEJJ", "name": "Guillaume Lemaitre", "avatar": null, "biography": "Guillaume is an open-source software engineer working at :probabl. He is a core maintainer of the scikit-learn and imbalanced-learn libraries.", "public_name": "Guillaume Lemaitre", "guid": "41faba07-5db9-5480-8bd8-f8de3b4d4146", "url": "https://pretalx.com/euroscipy-2026/speaker/MJKEJJ/"}, {"code": "SYEMSE", "name": "J\u00e9r\u00f4me Dock\u00e8s", "avatar": null, "biography": "J\u00e9r\u00f4me Dock\u00e8s is a software engineer at Probabl and one of the developers of Skrub.            https://github.com/jeromedockes", "public_name": "J\u00e9r\u00f4me Dock\u00e8s", "guid": "e7e77891-0f46-51e0-bd21-4167304c59e2", "url": "https://pretalx.com/euroscipy-2026/speaker/SYEMSE/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/MLEJZS/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/MLEJZS/", "attachments": []}, {"guid": "6e083084-0cb7-5212-a739-fe73ad190288", "code": "C7BCMN", "id": 96255, "logo": null, "date": "2026-07-21T10:10:00+02:00", "start": "10:10", "end": "2026-07-21T11:10:00+02:00", "duration": "01:00", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-96255-what-is-your-simulation-doing-right-now", "url": "https://pretalx.com/euroscipy-2026/talk/C7BCMN/", "title": "What Is Your Simulation Doing Right Now?", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Keynote", "language": "en", "abstract": "Your simulation is 40 hours into a 48-hour SLURM allocation and it has stopped making progress. You can't restart it, and you didn't instrument it. Until recently, Python's official answer was \"you should have thought about that earlier.\" That answer has changed.\n\nPython 3.14 and 3.15 quietly shipped the biggest upgrade to observability in the language's history: a safe, supported way to attach a debugger to any live Python process (`pdb -p`), and Tachyon, a sampling profiler in the standard library that attaches to a running process with virtually zero overhead and can tell you -- among other things -- which thread is hogging the GIL, at up to a million samples per second.\n\nBut scientific Python is observability's hardest case: long-running, thread-heavy, mostly native code underneath, and increasingly on the GPU. I'll demo what the new tools do on live processes, but will also be honest about where they still go dark today -- native frames, free-threaded builds, GPU timelines -- and lay out a plan for Python 3.16, which you can help shape as well.", "description": "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.\n\nBetween 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.\n\n### Act I: Observe without restarts.\nPython 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?\n\n### Act II: The three hard places.\nWhere the new tools still go dark, demonstrated rather than hand-waved:\n* native code: your NumPy kernel is currently one opaque frame,\n* free-threaded builds where the standard library leads and popular ecosystem tools still lag, and\n* GPUs where excellent vendor timelines exist but nothing speaks Python natively and no common trace format connects them.\n\n### Act III: The near future.\nPython 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.\n\nYou'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.\n\nNo 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "KXUG9A", "name": "\u0141ukasz Langa", "avatar": null, "biography": "CPython expert specializing in asynchronous programming and gradual typing. Over 15 years as a core developer of CPython. Former Python release manager. Former CPython Developer in Residence at the PSF. Original creator of the auto-formatter Black. Currently a software engineer for the Python Language Foundation team at Meta.", "public_name": "\u0141ukasz Langa", "guid": "417e4600-e4c9-5a3e-93e0-983efdc20d48", "url": "https://pretalx.com/euroscipy-2026/speaker/KXUG9A/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/C7BCMN/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/C7BCMN/", "attachments": []}, {"guid": "20fe01f7-78d0-573d-a090-a8bbac97583e", "code": "YTW8PA", "id": 90646, "logo": null, "date": "2026-07-21T11:30:00+02:00", "start": "11:30", "end": "2026-07-21T12:00:00+02:00", "duration": "00:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-90646-the-road-map-towards-scipy-2-0", "url": "https://pretalx.com/euroscipy-2026/talk/YTW8PA/", "title": "The road(map) towards SciPy 2.0", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "We first discuss recent developments in SciPy the library, focusing on new features implemented in recent releases and ongoing work. We then survey the road ahead and discuss the roadmap for evolving SciPy forward.", "description": "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.\n\nIn 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "37A7KU", "name": "Evgeni Burovski", "avatar": null, "biography": "A computational physicist by training, Evgeni has been contributing to the SciPy ecosystem for over a decade.", "public_name": "Evgeni Burovski", "guid": "67a21263-6fee-577e-ac6f-dc5182f8368d", "url": "https://pretalx.com/euroscipy-2026/speaker/37A7KU/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/YTW8PA/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/YTW8PA/", "attachments": []}, {"guid": "27d39fe6-f197-5580-881d-20667601c3b9", "code": "9QDAAZ", "id": 92984, "logo": null, "date": "2026-07-21T12:10:00+02:00", "start": "12:10", "end": "2026-07-21T12:30:00+02:00", "duration": "00:20", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-92984-splinebox-pure-python-toolkit-for-splines", "url": "https://pretalx.com/euroscipy-2026/talk/9QDAAZ/", "title": "splinebox: pure-python toolkit for splines", "subtitle": "", "track": "Interdisciplinary Frontiers and other Scientific Python Applications", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "We've developed a python-numba library for splines!\nIt's more flexible and easier to use than what is implemented in scipy, as well as implementing more basis functions (like exponential basis functions).", "description": "[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.\nRather 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.\n\nThe 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.\n\nThe implementation of `splinebox` in python+numba makes it easy to extend and read.\nPlease check out our [examples gallery](https://splinebox.readthedocs.io/en/stable/auto_examples/index.html) for inspiration.\n\nOur talk will describe the software decisions behind the project and illustrate its use.", "recording_license": "", "do_not_record": false, "persons": [{"code": "NJAER3", "name": "Florian Aymanns", "avatar": null, "biography": null, "public_name": "Florian Aymanns", "guid": "3f1e08cb-a3b7-5254-94ad-ef05d8b864f2", "url": "https://pretalx.com/euroscipy-2026/speaker/NJAER3/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/9QDAAZ/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/9QDAAZ/", "attachments": []}, {"guid": "26728c0d-bf8f-58bf-a080-4ee256222a43", "code": "CLUCAW", "id": 92754, "logo": null, "date": "2026-07-21T14:00:00+02:00", "start": "14:00", "end": "2026-07-21T14:30:00+02:00", "duration": "00:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-92754-pydata-sparse-finch-extending-sparse-computing-in-the-python-ecosystem", "url": "https://pretalx.com/euroscipy-2026/talk/CLUCAW/", "title": "PyData/Sparse & Finch: extending sparse computing in the Python ecosystem", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "Scientific Python Ecosystem offers a wide variety of numerical packages, such as NumPy, CuPy, or JAX. One of the domains that also captures a lot of attention in the community is sparse computing.\n\nIn this talk, we will present the current landscape of sparse computing in the Python ecosystem and our efforts to revive/expand it. Our main contributions to the Python ecosystem cover: (1) making a novel Finch sparse tensor compiler and Galley scheduler available for the community, (2) standardizing various aspects of sparse computing. We will show how to use the Finch compiler with the PyData/Sparse package and how it outperforms well-established alternatives for multiple kernels, such as MTTKRP or SDDMM.\n\nReal-world use-cases will show you how, step-by-step, Python practitioners can migrate their code to an Array API compatible version and benefit from tensor operator fusion and autoscheduling capabilities offered by the Finch compiler.\n\nApart from the existing Julia implementation, the number of sparse backends offered by PyData/Sparse will grow in the future to provide a Python-native alternatives for scipy.sparse and Numba solutions. One of them that is currently under development is finch-tensor-lite, a pure Python rewrite of Finch.jl compiler, meant to make the solution lightweight by dropping Julia runtime dependency while providing the majority of features.", "description": "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.\n\nNext, 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "GWCWWU", "name": "Mateusz Sok\u00f3\u0142", "avatar": null, "biography": "I'm a Software Engineer at Quansight, working on multitude of open source projects in the Scientific Python Ecosystem. You can find my GitHub profile here: https://github.com/mtsokol", "public_name": "Mateusz Sok\u00f3\u0142", "guid": "2d8841a5-1f26-539d-bb34-12287d2f9c59", "url": "https://pretalx.com/euroscipy-2026/speaker/GWCWWU/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/CLUCAW/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/CLUCAW/", "attachments": []}, {"guid": "aedfd0be-db61-514d-8e9a-b811dc8eead9", "code": "YFK3YB", "id": 92025, "logo": null, "date": "2026-07-21T14:40:00+02:00", "start": "14:40", "end": "2026-07-21T15:10:00+02:00", "duration": "00:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-92025-pixi-better-developer-experience-for-scientific-python-projects", "url": "https://pretalx.com/euroscipy-2026/talk/YFK3YB/", "title": "Pixi: better developer experience for scientific Python projects", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "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.", "description": "[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. \n\nIn 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.\n\nYou can also expect a quick live demo of some of the cool things made possible by Pixi :)\n\nNo prior knowledge is expected!", "recording_license": "", "do_not_record": false, "persons": [{"code": "MD3SSJ", "name": "Lucas Colley", "avatar": null, "biography": "I'm a core maintainer of [SciPy](https://scipy.org) and [Pixi](https://pixi.prefix.dev/latest/), and a member of [the Consortium for Python Data API Standards](https://data-apis.org). I recently finished a master's degree in Computer Science and Philosophy at the University of Oxford.", "public_name": "Lucas Colley", "guid": "970eabe7-7be2-5b31-ab0a-a0a6808b9a90", "url": "https://pretalx.com/euroscipy-2026/speaker/MD3SSJ/"}, {"code": "G9QWGL", "name": "Wolf Vollprecht", "avatar": null, "biography": "Wolf Vollprecht has been active in the Python open source community for the past 5 years. He is a core member of conda-forge and the conda steering council, and the original author of the mamba package manager. He also has extensive experience in high-performance C++ and Rust. 2 years ago he started prefix.dev where the team is focusing all efforts on making cross-platform, language independent package management great (on top of the conda ecosystem).", "public_name": "Wolf Vollprecht", "guid": "9721be6c-db58-5443-a160-08ef3080cd0b", "url": "https://pretalx.com/euroscipy-2026/speaker/G9QWGL/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/YFK3YB/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/YFK3YB/", "attachments": []}, {"guid": "3ce75b4f-3728-5c08-a90c-0f462fe03067", "code": "G7BJFJ", "id": 89809, "logo": null, "date": "2026-07-21T15:20:00+02:00", "start": "15:20", "end": "2026-07-21T15:40:00+02:00", "duration": "00:20", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-89809-automating-scientific-paper-classification-at-scale-with-retrieval-reranking-and-llms", "url": "https://pretalx.com/euroscipy-2026/talk/G7BJFJ/", "title": "Automating Scientific Paper Classification at Scale with Retrieval\u2013Reranking and LLMs", "subtitle": "", "track": "Applied AI & LLM Technologies and Use Cases", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "Scientific organizations struggle to extract actionable insights from publication data tagged with inconsistent and noisy author keywords. Automatically assigning papers to consistent, semantically grounded concepts is essential for reliable trend detection, search, and analytics.\n\nThis talk presents a production-grade, **two-stage classification pipeline** that tags hundreds of thousands of scientific papers against a **110K+ concept taxonomy**. Given a fixed hierarchical taxonomy extending OpenAlex's **4-level structure** with a granular concept layer, the system combines **vector-based retrieval**, **cross-encoder reranking**, and targeted **LLM validation** to achieve scalable and accurate paper classification.\n\nIn **Stage 1 (Candidate Retrieval)**, paper metadata (title, abstract, author keywords) is embedded using **SPECTER2** and queried against **Qdrant** to retrieve a small, high-recall candidate set from over **110,000 concepts**. In **Stage 2 (Reranking and Filtering)**, **cross-encoder models** perform fine-grained semantic matching, while **LLMs (Azure OpenAI)** are selectively applied to resolve ambiguous cases and produce confidence-scored assignments.\n\nDeployed on **millions of publications**, the system standardizes noisy keywords and enriches paper metadata with semantically consistent concept tags, enabling downstream analytics at scale.", "description": "## The Problem\n\nScientific 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.\n\nThis talk focuses on the paper classification problem: given a large, fixed taxonomy, how can we automatically and reliably tag papers at scale?\n\n## The Foundation: A Large-Scale Concept Taxonomy\n\nThe 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.)\n\n## Stage 1: Candidate Retrieval with Bi-Encoders\n\n**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.\n\n**Vector Search** Using **Qdrant**, we retrieve the top-N candidate concepts (typically N = 50\u2013100) via cosine similarity. This step reduces the search space from over **110,000 concepts** to a manageable candidate set while maintaining high recall.\n\n**Threshold Tuning** We discuss similarity threshold strategies that balance recall (avoiding missed relevant concepts) and precision (limiting noise passed to later stages).\n\n## Stage 2: Reranking with Cross-Encoders and LLMs\n\n**Why Cross-Encoders?** Bi-encoders scale well but miss fine-grained interactions between paper content and concept descriptions. Cross-encoders jointly encode paper\u2013concept pairs, capturing nuanced semantic relationships at higher computational cost.\n\n**Reranking Architecture** Cross-encoder models score each candidate pair, producing a high-precision ranking over Stage-1 results.\n\n**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.\n\n**Final Assignment** The system outputs ranked, **multi-label concept assignments** with calibrated confidence scores, selecting top-k concepts per paper based on learned thresholds.\n\n## Production Deployment and Impact\n\nThe pipeline is deployed on **millions of papers**, standardizing noisy author keywords and enriching metadata with semantically consistent concept tags. This enables:\n\n* Real-time trend detection (identifying emerging topics weeks early)\n* Cross-journal portfolio analytics\n* Data-driven strategic decision-making\n\nWe also discuss operational challenges, including batch processing, GPU utilization, cost\u2013accuracy trade-offs for cross-encoders, evaluation metrics (**Precision@k, NDCG**), and production monitoring.\n\n## Key Takeaways\n\nAttendees will learn:\n\n* Retrieval\u2013reranking design patterns for large label spaces\n* When to use **bi-encoders vs. cross-encoders** in production\n* Practical **Qdrant optimization** for large-scale vector search\n* Cross-encoder deployment and cost trade-offs\n* Selective LLM integration for context-aware filtering\n* Thresholding and confidence calibration for **multi-label classification**\n* Batch processing and GPU optimization strategies\n* How structured taxonomies improve classification accuracy at scale\n\n## Audience\n\nData 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "3U8HLG", "name": "Daniele Raimondi", "avatar": null, "biography": "Daniele is a data scientist with expertise in statistics, data science and AI, passionate about exploring the intersection of machine learning and financial markets. Since 2023, he is working at MDPI, one of the largest open-access publishers. A former national 400m sprinter.", "public_name": "Daniele Raimondi", "guid": "c7f80c08-2f1f-5dff-8d7b-c74fc8cd76d4", "url": "https://pretalx.com/euroscipy-2026/speaker/3U8HLG/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/G7BJFJ/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/G7BJFJ/", "attachments": []}, {"guid": "472ebd90-b586-5f19-b3df-3b89634ee8ce", "code": "U9TNWY", "id": 91601, "logo": null, "date": "2026-07-21T16:00:00+02:00", "start": "16:00", "end": "2026-07-21T16:20:00+02:00", "duration": "00:20", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-91601-optimize-the-geospatial-data-processing-with-apache-sedona-and-sedonadb", "url": "https://pretalx.com/euroscipy-2026/talk/U9TNWY/", "title": "Optimize the geospatial data processing with Apache Sedona and SedonaDB.", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "During this comprehensive talk, we will discuss how to optimize your spatial data processing using Apache Sedona, a distributed processing engine, and SedonaDB, a powerful data fusion-based database that treats spatial data as a first-class citizen. In this talk, you will understand how to optimize:\n- Distributed and non-distributed spatial join\n- How to optimize spatial partitioning and reduce data skew\n- How to leverage Spatial Apache Parquet and Geoparquet to efficiently store and retrieve data \n- Optimizing Apache Sedona Python applications to be more performant and consume less memory, incorporating Apache Arrow and SedonaDB\n- Powerful indexing techniques\n- Distributed K-nearest neighbor algorithm\n\nI will explain why the knowledge of optimization patterns is important and how understanding Apache Sedona's Python limitations is crucial to making your spatial data pipelines robust and efficient. The last part is to explain when use Apache Sedona and where SedonaDB fits.", "description": "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. \n\nThe talk consists of four major sections,\n- Introducing the Apache Sedona ecosystem and how Apache Sedona solves complex distributed spatial problems, like spatial partitioning and spatial joins\n- Explaining what Spatial Parquet and Geoparquet are and the problems they solve\n- Optimizing spatial processing pipelines, including\n    - reducing skew in spatial join\n    - evenly distributed spatial partitioning\n    - k nearest neighbor search\n    - effiecient user defined functions with Arrow optimization\n    - efficient storing and retrieving data from spatial Parquet\n    - powerful indexing techniques\n    - understanding of limitation of the Apache Sedona Python API\n- When to use Apache SedonaDB in your spatial data processing tasks.\n\nTo 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. \n\nSedonaDB 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "JMXEKT", "name": "Pawe\u0142 Tokaj", "avatar": null, "biography": "Pawe\u0142 Tokaj is a staff software engineer at Splunk and a PMC member of the Apache Sedona project who enjoys writing reliable, efficient software that helps others. His love for geospatial data started at the Warsaw University of Technology, where he graduated in geodesy and cartography.\n\nPawe\u0142\u2019s primary focus areas are distributed databases and systems, cloud computing, and geospatial data processing. He believes that open source projects make knowledge more accessible; he has contributed to Apache Sedona, Open Lineage, and Airbyte. He attends various conferences or meetups where he shares his knowledge as a speaker or participant. He is a technology nerd, spending a lot of his spare time reading books and articles and developing open source software.", "public_name": "Pawe\u0142 Tokaj", "guid": "4f2174fe-5812-58e7-930f-6850faba6b44", "url": "https://pretalx.com/euroscipy-2026/speaker/JMXEKT/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/U9TNWY/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/U9TNWY/", "attachments": []}, {"guid": "1cf31948-adfa-5208-b1d3-5ea59580d4f0", "code": "ZT3BMR", "id": 92202, "logo": null, "date": "2026-07-21T16:30:00+02:00", "start": "16:30", "end": "2026-07-21T16:50:00+02:00", "duration": "00:20", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-92202-embed-data-science-in-your-iot-device-with-micropython", "url": "https://pretalx.com/euroscipy-2026/talk/ZT3BMR/", "title": "Embed Data Science in your IoT device with MicroPython", "subtitle": "", "track": "Applied AI & LLM Technologies and Use Cases", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "Python is the standard solution for many machine learning and data science applications, from large cloud systems, to workstations, and even on larger embedded or robotics systems. But as we move down into more constrained environments regular (C)Python starts to be a less good fit.\nThe MicroPython project provides a Python implementation that is tailored for such environments,\nand this makes it possible scale down to microcontrollers with just a few megabytes of RAM (or less!).\nAs a bonus, MicroPython with WebAssembly also makes lightweight browser applications possible.\nIn this talk, we will discuss how to combine IoT devices, MicroPython and browser to build stand-alone sensor systems and laboratory gear for physical data science.", "description": "Typical Internet of Things devices send off most of the data to an external cloud service for analysis.\nThis causes challenges both in terms of privacy, poor reliability under poor connectivity, and loss-of-availability when the service is discontinued.\n\nWe 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.\n\nThis talk will cover how to build stand-alone devices for measuring and analyzing physical sensor data, using MicroPython. This includes these aspects:\n\n- Measuring the surroundings using sensors\n- Connectivity using WiFi\n- Data storage using on-board filesystem\n- Serving a webui for configuration/control, using Microdot\n- Automated data processing/analysis using DSP and ML, with emlearn-micropython\n- Enabling interactive data analysis via webui\n- Managing concurrency on microcontroller, using asyncio\n- Optional integration. Pull using HTTP, and/or push using Webhooks/MQTT\n\nSlides: https://github.com/jonnor/embeddedml/tree/master/presentations/euroscipy2026/presentation", "recording_license": "", "do_not_record": false, "persons": [{"code": "R7VPYA", "name": "Jon Nordby", "avatar": null, "biography": "Jon is a Machine Learning Engineer specialized in IoT systems. He has a Master in Data Science and a Bachelor in Electronics Engineering, and has published several papers on applied Machine Learning.\nHe has been contributing to open-source software since 2010.\n\nThese days Jon is co-founder and Head of Data Science at Soundsensing, a leading provider of condition monitoring solutions for commercial buildings and HVAC systems.\nHe is also the creator and maintainer of emlearn, an open-source Machine Learning library for microcontrollers and embedded systems.", "public_name": "Jon Nordby", "guid": "cba066a6-9301-5981-8b37-222f32db4126", "url": "https://pretalx.com/euroscipy-2026/speaker/R7VPYA/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/ZT3BMR/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/ZT3BMR/", "attachments": []}], "Room 1.19 (Ground Floor, Shannon)": [{"guid": "c2dc13f1-81b3-50fc-a0c1-db23162b6bc2", "code": "E3X9EX", "id": 92070, "logo": null, "date": "2026-07-21T09:30:00+02:00", "start": "09:30", "end": "2026-07-21T10:00:00+02:00", "duration": "00:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-92070-automatic-reconstruction-of-x-ray-scenes-with-python-and-datalab", "url": "https://pretalx.com/euroscipy-2026/talk/E3X9EX/", "title": "Automatic Reconstruction of X-ray Scenes with Python and DataLab", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "*Slides are now available [here](https://github.com/DataLab-Platform/DataLab/wiki/DataLab-Talk_EuroSciPy2026-static.pdf)!*\n\nIn the field of non-destructive testing, the French Alternative Energies and Atomic Energy Commission (CEA) entrusted CODRA with the specification and development of software for the automatic reconstruction of radiographic scenes from partial X-ray images.\n\nThe challenge was to assemble a full-field X-ray scene from multiple acquisitions obtained by moving a detector or juxtaposing imaging plates, without any prior metadata regarding position, orientation, or magnification.\n\nThe reconstruction processing pipeline includes several key steps:\n\n- image pre-processing and denoising,\n- robust blob detection,\n- homography estimation for geometric correction,\n- fusion of corrected sub-images into a coherent global scene.\n\nThe entire workflow was developed using open-source scientific Python libraries (NumPy, SciPy, scikit-image, OpenCV) and prototyped interactively with [**DataLab**](https://datalab-platform.com), an open-source platform for signal and image processing. [DataLab](https://datalab-platform.com) was remotely controlled to dynamically visualize intermediate results, tune parameters, and validate geometric transformations step by step.\n\nThis project illustrates how the scientific Python ecosystem enables the development of industrial-grade imaging software, from interactive prototyping to automated deployment, using 100% open-source components.", "description": "This talk presents a real-world industrial application of scientific Python in the domain of X-ray imaging and geometric reconstruction.\n\nUnlike 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.\n\nA 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:\n\n- interactively inspect intermediate images,\n- visualize detected patterns and geometric annotations,\n- adjust thresholds and filtering parameters,\n- compare transformation models in real time.\n\nThis 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.\n\nThe talk will include:\n\n- a walkthrough of the reconstruction strategy,\n- a discussion of the image processing challenges involved,\n- a live or recorded demonstration of the interactive prototyping environment with [DataLab](https://datalab-platform.com),\n- reflections on software architecture and reproducibility in scientific imaging workflows.\n\nThis 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "ABVPYX", "name": "Pierre Raybaut", "avatar": null, "biography": "**Pierre Raybaut** is a physicist and software engineer \u2014 with a background in optics and photonics engineering and a PhD in femtosecond lasers \u2014 known for creating [Spyder](https://www.spyder-ide.org/), the Scientific Python IDE, as well as [Python(x,y)](https://python-xy.github.io/) and [WinPython](https://winpython.github.io/), tools that helped establish Python as a first-class language for scientific computing.\n\nHe started his career as a research engineer at THALES Avionics, then spent over a decade at the French Alternative Energies and Atomic Energy Commission (CEA) as lead software developer, project manager for the Laser M\u00e9gajoule timing and fiducial system, and head of a research laboratory. Since 2018, he has been at CODRA, an industrial software company based in France, where he serves as Executive Vice President.\n\nPierre remains an active open-source contributor. Beyond Spyder, he created [guidata](https://github.com/PlotPyStack/guidata), [PlotPy](https://github.com/PlotPyStack/plotpy), the [PlotPyStack](https://github.com/PlotPyStack) ecosystem, and [DataLab](https://datalab-platform.com), an open-source platform for scientific and technical data processing and visualization.", "public_name": "Pierre Raybaut", "guid": "2574c596-3855-5415-9ccf-be1a633214d8", "url": "https://pretalx.com/euroscipy-2026/speaker/ABVPYX/"}, {"code": "LMY3JM", "name": "Marc Rabec le Gloahec", "avatar": null, "biography": "Domaines science et structure de la mati\u00e8re, mesures physiques et micro-\u00e9lectronique informatique industrielle, ing\u00e9nieur au CEA. Collaborations scientifiques dans le domaine des exp\u00e9riences plasmas laser-mati\u00e8re, instabilit\u00e9s param\u00e9triques, instabilit\u00e9s hydrodynamiques, \u00e9quations d\u2019\u00e9tat. Contribution au programmes NIF et LMJ. Activit\u00e9s actuelles dans le cadre de la s\u00e9curit\u00e9 globale, radiographies \u00e0 basse et haute \u00e9nergies.", "public_name": "Marc Rabec le Gloahec", "guid": "1f44d7c0-35ef-5bfd-a4a8-12a5a8c121c4", "url": "https://pretalx.com/euroscipy-2026/speaker/LMY3JM/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/E3X9EX/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/E3X9EX/", "attachments": []}, {"guid": "418df391-6649-507b-bdd8-b19a41ad7254", "code": "RBUGDR", "id": 90870, "logo": null, "date": "2026-07-21T11:30:00+02:00", "start": "11:30", "end": "2026-07-21T11:50:00+02:00", "duration": "00:20", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-90870-boring-ai-works-when-bert-beats-billion-parameter-models", "url": "https://pretalx.com/euroscipy-2026/talk/RBUGDR/", "title": "Boring AI Works: When BERT Beats Billion-Parameter Models", "subtitle": "", "track": "Applied AI & LLM Technologies and Use Cases", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "Recent advances in AI have shifted industries\u2019 attention toward integrating LLM-based systems. Even though LLMs can solve a wide range of business problems, they came with a significant complexity overhead. At same time, many real-world business applications involve well-defined objectives, predictable inputs, and clear evaluation criteria. \n\nToday, we are increasingly seeing a default pattern: for almost any NLP use case, teams prompt GPT-like models and pay the bill at the end of the month. However, this approach often introduces unnecessary complexity, costs, and operational risk. Many business and research problems exist in constrained environments that can be solved with simpler techniques, achieving the same or higher success rates.\n\nThis talk defends that fine-tuned BERT-based models remain a strong and often superior choice for targeted business use cases that require NLP-based solutions. I propose to present a real, in-production use case where a simple transformer-based classifier demonstrates a more favourable performance-cost trade-off than LLM-based approaches, driven by lower latency, reduced operational complexity, easier fine-tuning, and significantly lower maintenance costs.\n\nThe goal of this presentation is not to reject LLMs, but to promote a pragmatic, outcome-driven approach to NLP, where \u201cboring\u201d solutions often deliver the most value.", "description": "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.\n\nThis talk takes a step back and asks a simple question: Are we solving business problems, or just using the most trendy tools available?\n\nThrough a real production case study, I\u2019ll 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.\n\nImportantly, 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.\n\nIf AI is going to succeed in business, it won\u2019t 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.\n\nSometimes, the most impactful AI solution is also the most boring one.", "recording_license": "", "do_not_record": false, "persons": [{"code": "MR8NT3", "name": "Diogo Rodrigues", "avatar": null, "biography": "Senior AI Engineer with 7+ years of experience architecting and deploying end-to-end ML solutions at scale. Specialized in NLP, Generative AI (LLM, RAG), Vector Search, and MLOps.", "public_name": "Diogo Rodrigues", "guid": "e13ad492-bb53-5ffb-9c36-0db8b9ca9966", "url": "https://pretalx.com/euroscipy-2026/speaker/MR8NT3/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/RBUGDR/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/RBUGDR/", "attachments": []}, {"guid": "8eb6cd03-9b31-52ed-aae0-4c5054e5dda4", "code": "E8FCF9", "id": 90547, "logo": null, "date": "2026-07-21T14:00:00+02:00", "start": "14:00", "end": "2026-07-21T14:30:00+02:00", "duration": "00:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-90547-pygambit-drawtree-python-tools-for-game-theory", "url": "https://pretalx.com/euroscipy-2026/talk/E8FCF9/", "title": "PyGambit & DrawTree: Python tools for game theory.", "subtitle": "", "track": "Interdisciplinary Frontiers and other Scientific Python Applications", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "This talk will demonstrate how the PyGambit package for game theory can be used to construct games, and compute their Nash equilibria. Secondly, the talk will demonstrate the DrawTree package and challenges associated with drawing game trees, given the constraints of visualising \u201cinformation sets\u201d 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.", "description": "The [\u201cGambit\u201d]( 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.\n\nRecent 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).\n\nThis 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 \u201cinformation sets\u201d 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "JZLU8X", "name": "Ed Chalstrey", "avatar": null, "biography": "Research Data Scientist and Software Engineer at The Alan Turing Institute in London. I have worked for over a decade in scientific computing, in fields ranging from computational biology, environmental sciences, digital humanities and more.\nI have also worked on a lot of Python packages!", "public_name": "Ed Chalstrey", "guid": "431c3142-eb03-5da2-ba9f-36a1baece72a", "url": "https://pretalx.com/euroscipy-2026/speaker/JZLU8X/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/E8FCF9/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/E8FCF9/", "attachments": []}, {"guid": "9d38861a-f211-560e-931f-85fdd5b9a491", "code": "8KCT3D", "id": 93019, "logo": null, "date": "2026-07-21T14:40:00+02:00", "start": "14:40", "end": "2026-07-21T15:10:00+02:00", "duration": "00:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-93019-the-illusion-of-compliance-auditing-llm-as-a-judge-systems", "url": "https://pretalx.com/euroscipy-2026/talk/8KCT3D/", "title": "The Illusion of Compliance: Auditing LLM-as-a-Judge Systems", "subtitle": "", "track": "Applied AI & LLM Technologies and Use Cases", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "LLM-as-a-Judge systems are increasingly deployed in high-stakes settings - screening job applicants, triaging medical cases, assessing credit risk, and flagging legal exposure. As the EU AI Act takes effect in August 2026 with penalties up to \u20ac35M for biased high-risk systems, organizations are investing heavily in fairness audits. But passing a bias check does not guarantee fairness. Standard Python fairness pipelines rarely detect this shift. In a controlled hiring experiment on real resumes, we demonstrate how alignment and potentially bias-mitigation techniques can reduce aggregate disparities while redistributing harm across intersectional subgroups.", "description": "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. \nWe\u2019ll walk through Python workflows that:\n\n- Move beyond single-attribute slicing to multi-dimensional group analysis\n\n- Implement additivity testing (quantify non-linear discrimination)\n\n- Detect dimensional heterogeneity (when gender improves but race worsens)\n\n- Surface trade-offs introduced by alignment and tuning\n\nAlthough 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "9B7HES", "name": "Vasu Sharma", "avatar": null, "biography": "- Currently interested in AI Safety and Alignment Research | Writes at https://permutedsense.substack.com/\n- Open source and privacy-preserving tools enthusiast\n\nPrevious experience working as a data scientist on varied business propositions ranging from detecting scientific fraud in publishing, supply chain optimization, customer attrition, upselling/cross-selling card products, web personalization and customer-merchant affinity.", "public_name": "Vasu Sharma", "guid": "ef71aa04-d0be-5c5f-9481-942cf1c35587", "url": "https://pretalx.com/euroscipy-2026/speaker/9B7HES/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/8KCT3D/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/8KCT3D/", "attachments": []}, {"guid": "6d7fb94f-0c1e-520a-ae71-d4c1f23395d5", "code": "9UKDPK", "id": 90465, "logo": null, "date": "2026-07-21T15:20:00+02:00", "start": "15:20", "end": "2026-07-21T15:40:00+02:00", "duration": "00:20", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-90465-pycabinet-a-python-toolbox-for-end-to-end-transcriptomics-and-omics-analysis", "url": "https://pretalx.com/euroscipy-2026/talk/9UKDPK/", "title": "PyCabinet: A Python Toolbox for End-to-End Transcriptomics and Omics Analysis", "subtitle": "", "track": "Life Sciences and Biomedicine", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "Background\nModern genomic research increasingly relies on diverse computational analyses, ranging from differential expression studies to single-cell and spatial transcriptomics. However, laboratory scientists often encounter significant hurdles navigating scattered documentation, heterogeneous tool ecosystems, and inconsistent workflows across platforms.\n\nObjective\nWe present PyCabinet, a comprehensive Python-based analysis platform designed to consolidate the fragmented genomics tool landscape into a unified, accessible framework. PyCabinet aims to provide a \u201ctranscriptomics toolbox\u201d that guides researchers seamlessly from raw FASTQ files to publication-ready results.\n\nApproach\nPyCabinet offers:\n\nEnd-to-end workflow integration: A seamless progression from raw sequencing data to advanced downstream analyses.\n\nModular tool selection: Multiple algorithmic options for each analysis step, allowing researchers to select methods tailored to their data and scientific questions.\n\nComprehensive analysis coverage: Support for differential gene expression (DEG), gene regulatory network (GRN) analysis using graph neural networks (GNNs), single-cell RNA-seq, spatial transcriptomics, and a continually expanding set of analytical capabilities.\n\nUnified interface: Consistent Python API and comprehensive documentation across all modules, minimizing the learning curve and technical barriers for laboratory scientists.", "description": "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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "RCQBPV", "name": "Ishita jain", "avatar": null, "biography": "My name is Ishita, and I am a PhD student at the Technical University of Darmstadt. Alongside my doctoral research, I am independently developing BioCabinet as a personal project, separate from my PhD work.\n\nI started this project with the goal of making genomic data analysis more accessible to wet-lab scientists, particularly those who face steep technical barriers when working with complex, multi-modal datasets. BioCabinet is designed to bring multiple analytical tools together in one place, offering users the flexibility to compare methods, explore results across modalities, and access integrated documentation directly within the analysis workflow.\n\nA key motivation behind this project is to continuously evolve the platform alongside emerging technologies. This includes incorporating LLM-based chatbots trained on extensive biological and technical documentation, enabling researchers to ask questions, navigate tools, and better understand their data in an intuitive way.\n\nThrough this project, I aim to contribute a community-driven, up-to-date analysis framework that lowers the barrier to entry for advanced genomics research while remaining adaptable to future developments in the field.", "public_name": "Ishita jain", "guid": "e9b65b42-2d8f-560d-bad5-8a0d0e6d045b", "url": "https://pretalx.com/euroscipy-2026/speaker/RCQBPV/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/9UKDPK/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/9UKDPK/", "attachments": []}, {"guid": "3c3a14bc-2f12-574c-9665-32da1365b0a5", "code": "WENFS9", "id": 92032, "logo": null, "date": "2026-07-21T16:00:00+02:00", "start": "16:00", "end": "2026-07-21T16:20:00+02:00", "duration": "00:20", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-92032-unpacking-parallelising-networkx-algorithms-in-nx-parallel-backend", "url": "https://pretalx.com/euroscipy-2026/talk/WENFS9/", "title": "Unpacking parallelising NetworkX algorithms in nx-parallel backend", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "Hi! Have you ever run a NetworkX algorithm on a large graph and watched it take\u2026 longer than you expected? You look at your machine, see all those CPU cores sitting idle, and wonder \u2014 shouldn\u2019t this be faster?\n\nNetworkX is one of the most widely used graph analysis libraries in Python. But as the graph sizes become more realistic and huge, the performance becomes a bottleneck. So what if we could make NetworkX faster \u2014 without rewriting it in C, and without giving up its philosophy?\n\nIn this talk, I\u2019ll introduce **nx-parallel**, a backend that brings multi-core parallelism to NetworkX algorithms with the help of Joblib. But parallelism isn\u2019t just a magic switch you turn on. We\u2019ll dig into what actually makes a graph algorithm embarrassingly parallel, why only certain algorithms qualify, and how design decisions determine whether parallelism truly scales.", "description": "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.\n\nThe discussion then focuses on embarrassingly parallel algorithms in the context of graph analysis\u2014specifically, 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.\n\nNext, 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.\n\nThen, I introduce should_run heuristics, which determine whether parallel execution is beneficial for a given workload, ensuring that parallelism is applied only when appropriate.\n\nFinally, 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "8WLXFT", "name": "Akshita Sure", "avatar": null, "biography": "I\u2019m Akshita, a Computer Science undergraduate at IIIT Gwalior, and I\u2019m really passionate about building systems that are both technically strong and meaningful in impact. A big part of my journey has been through open source. I also enjoy competitive programming and problem-solving. I\u2019m particularly drawn to spaces where I can learn deeply, collaborate with others, and contribute meaningfully. Beyond tech, I\u2019ve trained in Carnatic music for over 10 years and have won several competitions. Overall, I see myself as someone who takes initiative, brings clarity to a team, and is constantly looking to grow \u2014 not just as an engineer, but as someone who can create impact and uplift others along the way :)", "public_name": "Akshita Sure", "guid": "52d51e34-383d-5bc0-9c8e-8043abd82e6d", "url": "https://pretalx.com/euroscipy-2026/speaker/8WLXFT/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/WENFS9/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/WENFS9/", "attachments": []}, {"guid": "9b80f32b-a31f-5f8f-b9c5-9b999f255a14", "code": "EBDPBB", "id": 91947, "logo": null, "date": "2026-07-21T16:30:00+02:00", "start": "16:30", "end": "2026-07-21T16:50:00+02:00", "duration": "00:20", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-91947-lessons-from-building-a-large-scale-engineering-simulation-data-processing-library", "url": "https://pretalx.com/euroscipy-2026/talk/EBDPBB/", "title": "Lessons from Building a Large-Scale Engineering Simulation Data Processing Library", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "Pre- and post-processing of large engineering simulation datasets in some scientific domains often demand performance that pure Python cannot yet deliver, and the general approach within the scientific Python ecosystem for overcoming the performance barrier is the combination of Python with compiled languages.\n \nIn this talk, I will share practical insights, experiences, and lessons drawn from the development and maintenance of PyDPF-Core, an open-source library that interacts with a C/C++ backend via a client-server architecture for the processing of large engineering simulation datasets. We will start by discussing the challenges of developing and maintaining such a library and then examine how each of these challenges were solved for PyDPF-Core.\n \nThe focus of the talk is on transferrable insights and my goal is for attendees to leave the talk with:\n- Knowledge of architectural blueprints that can be applied to their own high-performance python projects, especially those involving the processing of large simulation datasets;\n- Patterns for managing complexity in large scientific codebases; and\n- Understanding the trade-offs that might be encountered.", "description": "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.\n \nIn 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.\n \nThese 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.\n \nThis talk will touch how each of these challenges have been solved by briefly examining the following:\n- Modelling data that is \"aware\" of what it describes\n- The hourglass interface pattern for ensuring that the Python client and C/C++ server can independently evolve\n- Operator-based pipelines for composable data processing workflows\n- Techniques for reducing client-server data transfers\n- Templating and automated code generation techniques for API scalability\n- Leveraging third party python libraries for data visualization\n- Sustainable CI/CD practices for testing and library documentation generation.\n \nPre-requisites:\n- No deep C/C++ knowledge required, the talk is not intended to be technical\n- Basic understanding of client-server concepts\n \nReferences:\n- PyDPF-Core repository: https://github.com/ansys/pydpf-core\n- Documentation: https://dpf.docs.pyansys.com/\n- Hourglass Interface pattern: CppCon talk on stable ABI boundaries", "recording_license": "", "do_not_record": false, "persons": [{"code": "9KEKRJ", "name": "Muhammed Adedigba", "avatar": null, "biography": "I hold a Joint Masters Degree in Advanced Solid Mechanics from the National Technical University of Athens, Universit\u00e0 della Calabria, \u00c9cole Centrale de Lille, and Universit\u00e9 de Lille.\n\nI currently work as an R&D Software Engineer for Synopsys and I currently contribute to multiple projects within the PyAnsys OSS ecosystem.", "public_name": "Muhammed Adedigba", "guid": "158e4e61-5970-56a3-9600-043ef55cda04", "url": "https://pretalx.com/euroscipy-2026/speaker/9KEKRJ/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/EBDPBB/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/EBDPBB/", "attachments": []}], "Room 2.41 (First Floor, Turing)": [{"guid": "32f72a60-9176-5af4-8b66-192bf30cbb79", "code": "QJRACH", "id": 92135, "logo": null, "date": "2026-07-21T11:30:00+02:00", "start": "11:30", "end": "2026-07-21T12:00:00+02:00", "duration": "00:30", "room": "Room 2.41 (First Floor, Turing)", "slug": "euroscipy-2026-92135-setu-bridging-simulators-to-probabilistic-programming-in-jax", "url": "https://pretalx.com/euroscipy-2026/talk/QJRACH/", "title": "setu: Bridging Simulators to Probabilistic Programming in JAX", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "Many scientific models, from climate systems to neural circuits, are defined as simulators: computer programs that generate data from parameters but provide no tractable likelihood function. This makes them invisible to probabilistic programming languages (PPLs) like PyMC and NumPyro, which require explicit likelihoods for Bayesian inference. Practitioners are forced to choose: make simplifying assumptions about the simulator to use a PPL, or use the real simulator and give up the rich modeling capabilities PPLs offer, such as prior specification, uncertainty quantification and exploitation of hierarchical structures.\n\nWe present `setu` (\"bridge\"), a JAX-native Python package that closes this gap. `setu` uses generative neural networks trained on simulated data to learn a neural surrogate of the likelihood. This learned likelihood can then be exported directly into PPLs via a simple API: `nle.to_pymc()` or `nle.to_numpyro()`. Once inside a PPL, the full Bayesian toolbox becomes available: hierarchical models, custom priors, posterior predictive checks, and standard MCMC samplers \u2014 all running on a simulator that was previously out of reach.\n\nThe package follows a clean simulate, train, validate, export workflow, with built-in diagnostics to ensure the learned likelihood is trustworthy before it ever enters a PPL. In this talk, we walk through the motivation, design, and a real-world example showing how a black-box simulator gains full PPL capabilities.", "description": "### Background and motivation\n\nSimulation-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.\n\nLast 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.\n\nThis 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.\n\n### What `setu` does\n\n1. **Simulate**: Run your simulator to generate paired (parameter, data) samples. Usually happens on the user side, but `setu` provides utilities for parallelization.\n2. **Train**: Fit a normalizing flow (masked autoregressive flows or neural spline flows) to learn the conditional density p(data | parameters) \u2014 the likelihood.\n3. **Validate**: Before trusting the learned likelihood, run built-in diagnostic checks: classifier two-sample tests (C2ST), distribution shift detection, and training convergence monitoring.\n4. **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.\n\n### Why JAX?\n\nBuilding natively in JAX was a strategic choice:\n- **PyMC integration**: PyMC's backend (PyTensor) has a direct JAX compilation path, making the bridge nearly zero-overhead.\n- **NumPyro**: Already JAX-native, so the integration is trivial.\n- **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.\n\n### Talk outline (25 minutes)\n\n1. **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.\n2. **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.\n3. **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.\n4. **Validation matters** (3 min): Why you must check your learned likelihood before trusting it, and how it is done in `setu`.\n5. **Ecosystem and future** (2 min): Current status, roadmap, and how to get involved.\n\n### Key takeaways for the audience\n\n- Neural density estimation can turn simulators into a likelihood function usable by PPLs.\n- The simulate, train, validate, export workflow makes this practical and safe.\n- `setu` is designed for scientists who already know PyMC or NumPyro and want to use their real simulators instead of simplified analytical models.\n- Validation is essential: approximate likelihoods need rigorous checking.\n\n### Relevance to EuroSciPy\n\nThis 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "8MTSZC", "name": "Jan Boelts (Teusen)", "avatar": null, "biography": "Jan initially immersed himself in the realms of cognitive science and computational neuroscience. However, he couldn\u2019t resist the siren call of Bayesian machine learning, and his PhD evolved into a mission to enhance the user-friendliness of this complex field. He set out to bridge cutting-edge methods with user-friendly software, making the world of simulation-based inference more accessible for practitioners. In 2024, he joined the appliedAI Institute for Europe, ready to continue his journey of making advanced methodologies approachable and transformative.", "public_name": "Jan Boelts (Teusen)", "guid": "b2af9c25-f29e-51b9-afa3-2f6baacd9dea", "url": "https://pretalx.com/euroscipy-2026/speaker/8MTSZC/"}, {"code": "XQT9BK", "name": "sethaxen", "avatar": null, "biography": null, "public_name": "sethaxen", "guid": "54e65ded-2ae2-57d8-8d63-32c94579e3a1", "url": "https://pretalx.com/euroscipy-2026/speaker/XQT9BK/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/QJRACH/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/QJRACH/", "attachments": []}, {"guid": "4ed3215a-55a3-569e-835c-c6a9e144221a", "code": "VHAXMC", "id": 93020, "logo": null, "date": "2026-07-21T14:00:00+02:00", "start": "14:00", "end": "2026-07-21T14:30:00+02:00", "duration": "00:30", "room": "Room 2.41 (First Floor, Turing)", "slug": "euroscipy-2026-93020-interactive-visualizations-anywhere", "url": "https://pretalx.com/euroscipy-2026/talk/VHAXMC/", "title": "Interactive visualizations anywhere", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Talk (25 mins + Q&A)", "language": "en", "abstract": "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.\n\nThe 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. \n\nSecondly, 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).", "description": "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.\n\nThe 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. \n\nSecondly, 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).", "recording_license": "", "do_not_record": false, "persons": [{"code": "T7ARCM", "name": "Almar Klein", "avatar": null, "biography": "I got hooked on Python during my PhD in medical image analysis. I'm now an independent software engineer, taking an interest in (3D) visualization, bringing Python to the web, WebAssembly, and more. In the past few years my main focus is on growing wgpu and PyGfx.", "public_name": "Almar Klein", "guid": "175e69e0-5882-5513-838c-53a74c17ab3f", "url": "https://pretalx.com/euroscipy-2026/speaker/T7ARCM/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/VHAXMC/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/VHAXMC/", "attachments": []}, {"guid": "d6dcabfd-900d-54c0-85ae-83fbb6cfb103", "code": "79VCDC", "id": 93023, "logo": null, "date": "2026-07-21T15:20:00+02:00", "start": "15:20", "end": "2026-07-21T15:40:00+02:00", "duration": "00:20", "room": "Room 2.41 (First Floor, Turing)", "slug": "euroscipy-2026-93023-teaching-scientific-programming-in-the-age-of-agentic-coding", "url": "https://pretalx.com/euroscipy-2026/talk/79VCDC/", "title": "Teaching scientific programming in the age of agentic coding", "subtitle": "", "track": "Community, Education, and Outreach", "type": "Talk (15 mins + Q&A)", "language": "en", "abstract": "Learning to code has seldom received the due attention it needs in the history of computing. From undergraduate students to the software engineers, programming is picked up either as a self-taught skill in their own time or, more effectively, by participating in bootcamps or workshops organized by volunteers, research software engineers (RSEs), librarians, and so on. Agentic coding is replacing or could potentially replace as the first choice tool in several programming tasks, and this combines LLMs with tools to ground it such as MCPs and tool-calling. This thought provoking talk, questions whether should we continue teaching programming as we do today or adapt it to today's reality.", "description": "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:\n\n- 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.\n- 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.\n- Memorizing syntax - Traditionally this is done by following tutorials and reading documentation.\n- 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.\n- 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.\n\nIf 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?", "recording_license": "", "do_not_record": false, "persons": [{"code": "GSUJQR", "name": "Ashwin Mohanan", "avatar": null, "biography": "Ashwin is a training coordinator for Mimer (https://mimer-ai.eu/), the AI Factory located in Sweden, which is part of the EuroHPC Joint Undertaking initiative. Ashwin has a background in Mechanical and Aerospace Engineering and during his Ph.D, he delved deep in to the ecosystem, by contributing to several active scientific Python projects such as FluidDyn, Transonic and Pythran. He has also participated as a speaker in PyCon Sweden and enjoys engaging with Python community through workshops, courses, conferences and meetups.", "public_name": "Ashwin Mohanan", "guid": "f956e732-58b8-56f3-8a98-e8359164b557", "url": "https://pretalx.com/euroscipy-2026/speaker/GSUJQR/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/79VCDC/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/79VCDC/", "attachments": []}]}}, {"index": 5, "date": "2026-07-22", "day_start": "2026-07-22T04:00:00+02:00", "day_end": "2026-07-23T03:59:00+02:00", "rooms": {"Room 1.38 (Ground Floor, Turing)": [{"guid": "3cbe822b-9cac-50fc-9a6f-77776a601c04", "code": "D9FJAC", "id": 95367, "logo": null, "date": "2026-07-22T09:00:00+02:00", "start": "09:00", "end": "2026-07-22T10:30:00+02:00", "duration": "01:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-95367-deal-with-imbalanced-classification-using-scikit-learn", "url": "https://pretalx.com/euroscipy-2026/talk/D9FJAC/", "title": "Deal with imbalanced classification using scikit-learn", "subtitle": "", "track": "Applied AI & LLM Technologies and Use Cases", "type": "Tutorial", "language": "en", "abstract": "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.\n\nWe 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.\n\nThe 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.\n\nThe material is available here: https://github.com/probabl-ai/calibration-cost-sensitive-learning", "description": "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.\n\nWe 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.\n\nThe 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.\n\nThe material is available here: https://github.com/probabl-ai/calibration-cost-sensitive-learning", "recording_license": "", "do_not_record": false, "persons": [{"code": "MJKEJJ", "name": "Guillaume Lemaitre", "avatar": null, "biography": "Guillaume is an open-source software engineer working at :probabl. He is a core maintainer of the scikit-learn and imbalanced-learn libraries.", "public_name": "Guillaume Lemaitre", "guid": "41faba07-5db9-5480-8bd8-f8de3b4d4146", "url": "https://pretalx.com/euroscipy-2026/speaker/MJKEJJ/"}, {"code": "DDGQHA", "name": "Anne Beyer", "avatar": null, "biography": "I'm an open-source software developer with a background in computational linguistics and a contributor to scikit-learn.", "public_name": "Anne Beyer", "guid": "f273b132-aa27-50c8-8117-d07d71ed62da", "url": "https://pretalx.com/euroscipy-2026/speaker/DDGQHA/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/D9FJAC/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/D9FJAC/", "attachments": []}, {"guid": "04b1ec51-7013-5e67-a7b6-d6a50c1e2ed0", "code": "MYVDAK", "id": 91132, "logo": null, "date": "2026-07-22T11:00:00+02:00", "start": "11:00", "end": "2026-07-22T12:30:00+02:00", "duration": "01:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-91132-do-you-know-how-well-your-model-is-doing-evaluate-your-llms", "url": "https://pretalx.com/euroscipy-2026/talk/MYVDAK/", "title": "Do you know how well your model is doing? Evaluate your LLMs", "subtitle": "", "track": "Applied AI & LLM Technologies and Use Cases", "type": "Tutorial", "language": "en", "abstract": "Large Language Models (LLMs) are becoming central to modern applications, yet effectively evaluating their performance remains a significant challenge. How do you objectively compare different models, benchmark the impact of fine-tuning, or ensure your LLM responses adhere to safety guidelines (guard-railing)? This hands-on workshop addresses these critical questions.", "description": "Prerequisites:\n\nHave experience coding in Python (with Python installed in the local machine)\nBasic understanding of machine learning and LLMs\nExperience with Hugging Face Transformers is preferred but not necessary\nA Hugging Face Hub account (sign up for free)\nA modern computer that can fine-turn small LLMs locally\n\nDescription:\n\nWe 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.\n\nFinally, 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "8EGVC9", "name": "Cheuk Ting Ho", "avatar": null, "biography": "After having a career as a Data Scientist and Developer Advocate, Cheuk dedicated her work to the open-source community. Currently, she is working as a developer advocate for JetBrains. She has co-founded Humble Data, a beginner Python workshop that has been happening around the world. Cheuk also started and hosted a Python podcast, PyPodCats, which highlights the achievements of underrepresented members in the community. She has served the EuroPython Society board for two years and is now a fellow and director of the Python Software Foundation.", "public_name": "Cheuk Ting Ho", "guid": "6acb0b45-07a8-5f1c-a3fa-45ae8f0a9858", "url": "https://pretalx.com/euroscipy-2026/speaker/8EGVC9/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/MYVDAK/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/MYVDAK/", "attachments": []}, {"guid": "859b39e2-a038-5bb5-9345-374add521ccb", "code": "CGY37C", "id": 92719, "logo": null, "date": "2026-07-22T14:00:00+02:00", "start": "14:00", "end": "2026-07-22T15:30:00+02:00", "duration": "01:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-92719-quantum-physics-simulations-using-qutip", "url": "https://pretalx.com/euroscipy-2026/talk/CGY37C/", "title": "Quantum Physics Simulations using QuTiP", "subtitle": "", "track": "Physical Sciences and Engineering", "type": "Tutorial", "language": "en", "abstract": "Quantum technologies, ranging from basic studies of quantum dynamics to new applications in quantum computing, require computational tools that can handle sophisticated use cases but are accessible for everyone. QuTiP (Quantum Toolbox in Python) is an open\u2011source library that has become an important part of academic research as well as industry. It is widely used for modeling open quantum systems, simulating quantum circuits, studying stochastic effects and testing quantum algorithms. In this tutorial we will explore specific features of QuTiP by calculating the dynamics of closed and open quantum systems, and simulating a quantum circuit.", "description": "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.\n\nFor 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.\n\nFor 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.\n\nCome 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "LDW93T", "name": "Maximilian Meyer-M\u00f6lleringhof", "avatar": null, "biography": "- 2022, Bachelor in Physics, University of Vienna, Austria\n- 2024, Master in Quantum Technology, Uppsala University, Sweden\n- 2024 - present, active contributer to QuTiP\n- 2025 - present, PhD candidate, Uni Luxembourg", "public_name": "Maximilian Meyer-M\u00f6lleringhof", "guid": "631347bd-63c5-53db-b4f1-213305bdfdb8", "url": "https://pretalx.com/euroscipy-2026/speaker/LDW93T/"}, {"code": "YDXERP", "name": "Alexander Pitchford", "avatar": null, "biography": "Currently working as Lecturer in the [Mathematics Dept of Aberystwyth University](https://www.aber.ac.uk/en/maths/). I am part of the Administration Team for [QuTiP](http://qutip.org/) - the Quantum Toolkit in Python. I introduced the quantum control package into QuTiP. Through this I also have close ties with the [Quantum Information Physics Theory Research Team](https://www.riken.jp/en/research/labs/rqc/qtm_inf_phys_theor_res/)\n\nPrior to my current job, I completed a MPhys, then PhD Physics at Aberystwyth University. Before that I worked as a software developer / consultant in manufacturing simulation and finance process automation.", "public_name": "Alexander Pitchford", "guid": "e75aef2d-de2d-540f-ba11-f258d070ca65", "url": "https://pretalx.com/euroscipy-2026/speaker/YDXERP/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/CGY37C/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/CGY37C/", "attachments": []}, {"guid": "94afb0fc-97be-55af-9596-9f5d97bcb668", "code": "HX7ZZJ", "id": 91962, "logo": null, "date": "2026-07-22T16:00:00+02:00", "start": "16:00", "end": "2026-07-22T17:30:00+02:00", "duration": "01:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-91962-introduction-to-profiling", "url": "https://pretalx.com/euroscipy-2026/talk/HX7ZZJ/", "title": "Introduction to Profiling", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Tutorial", "language": "en", "abstract": "Does your code feel too slow? Do you want to speed it up, but don\u2019t know where to start?\n\nThis tutorial introduces attendees to the fundamentals of profiling in Python\u2014why, what, when and how to profile. We start by using Python\u2019s built-in `cProfile` module to figure out which parts of the code take up most of the runtime, then introduce a third-party module to visualise profiling results and get an overview over the function call hierarchy. In the second half, we use a line-level profiler to precisely pinpoint even a less obvious performance issue, before closing with an outlook on new profiling features coming in Python 3.15 this autumn.\n\nThroughout the tutorial, we include interactive exercises that build on each other. Attendees will get hands-on experience using these tools to systematically investigate performance issues in a Python code base.", "description": "This tutorial introduces attendees to the fundamentals of profiling in Python\u2014why, what, when and how to profile.\n\nIn the first half, we demonstrate function-level profiling using the Python standard library\u2019s `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\u2019ll give an outlook on the new `profiling` module and Tachyon sampling profiler coming in Python 3.15 this autumn.\n\nThroughout 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.\n\n**Schedule:**\nIntroduction: Why, What & When to Profile (10 min)\nFunction-Level Profiling with cProfile (25 min)\nVisualising cProfile Results (15 min)\nLine-Level Profiling (25 min)\nOutlook: Changes in Python 3.15 (10 min)\nConclusion & Next Steps (5 min)\n\nThis 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.\nAs 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "S3DADD", "name": "Jost Migenda", "avatar": null, "biography": "Jost is a Senior Research Software Engineer at King\u2019s College London, where they work on software projects ranging from astrophysics to Trusted Research Environments for analysing medical data. They are a certified Carpentries instructor and regularly develop and deliver training courses, with a focus on Python and high-performance computing for researchers.\n\nJost received a PhD in astroparticle physics from the University of Sheffield and is a maintainer of several widely used supernova neutrino codes, including [SNEWPY](https://joss.theoj.org/papers/10.21105/joss.03772) and [sntools](https://joss.theoj.org/papers/10.21105/joss.02877).", "public_name": "Jost Migenda", "guid": "4b93456e-2c58-5586-8891-31652f58a0a4", "url": "https://pretalx.com/euroscipy-2026/speaker/S3DADD/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/HX7ZZJ/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/HX7ZZJ/", "attachments": []}], "Room 1.19 (Ground Floor, Shannon)": [{"guid": "94260ab3-f3d3-565c-ac3f-77ae2133a382", "code": "SVL9NV", "id": 95237, "logo": null, "date": "2026-07-22T09:00:00+02:00", "start": "09:00", "end": "2026-07-22T10:30:00+02:00", "duration": "01:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-95237-reproducible-dependency-management-with-pixi", "url": "https://pretalx.com/euroscipy-2026/talk/SVL9NV/", "title": "Reproducible Dependency Management with Pixi", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Tutorial", "language": "en", "abstract": "Learn how to manage your conda- and pip-based Python dependencies with pixi. With its declarative approach, pixi provides a reliable way for reproducible\nPython environments. Its design is based on experiences drawn from tools such as `pip`, `conda` and `mamba` as well as Rust's `cargo`.", "description": "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.\n\nIn 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.\n\n## Audience\n\nThis tutorial is for participants who:\n\n1. Have a solid Python knowledge\n2. Are familiar with the **basic** use of `pip` or similar tools\n3. Would like to learn what pixi brings to dependency management\n4. Would like get hands-on experience with Pixi", "recording_license": "", "do_not_record": false, "persons": [{"code": "9KSJ3K", "name": "Mike M\u00fcller", "avatar": null, "biography": "Dr. Mike M\u00fcller has been working with Python since 1999 and teaching it professionally since 2004. As a trainer at Python Academy (https://www.python-academy.com), he has taught over 580 Python courses totaling more than 1,400 teaching days to thousands of participants worldwide.\n\nMike has taught more than 75 tutorials at Python conferences, including 29 tutorials at PyCon US over the years. He is known for his hands-on teaching approach, live coding demonstrations, and comprehensive course materials that participants can use as references long after the tutorial ends. His tutorials blend practical examples with solid theoretical foundations, making complex topics accessible and immediately applicable.\n\nBeyond teaching, Mike is deeply involved in the Python community. He has organized conferences including PyCon DE, EuroSciPy, and numerous BarCamps. His contributions to the community have been recognized with the PSF Community Service Award and PSF Fellow status. He serves as chair of the German Python Software Verband.\n\nMike holds a doctorate in hydrology and brings a scientific perspective to programming education. He believes in learning by doing and creates supportive environments where participants feel comfortable asking questions and experimenting with code.\n\n# Dr. Mike M\u00fcller\n\n## Education\n\n- German Diplom-Ingenieur Wasserwirtschaft (5 years) at University of\n  Technology Dresden,\n  Germany -- Wasserwirtschaft literal translation water management, engineering\n  degree in water resources management with focus on groundwater hydrology and\n  modelling\n- MS in Hydrology and Water Resources at University of Arizona, Tucson, USA\n- Ph.D. in Mining Hydrology at BTU Cottbus, Germany -- Development of a coupled\n  surface water and groundwater model for open pit mine lakes (PITLAKQ)\n\n## Work Experience\n\n- Combination of hydrology and software development\n- Coupling of models\n- Python teaching -- since 2004, >1500 full teaching days with focus on scientist and engineers\n\n## Model Coupling\n\nI have experience in coupling different hydrological and hydraulic models, such as:\n\n### PITLAKQ\n\nThis is my Ph.D. work that couples a finite volume groundwater model (PCGEOFIM),\na hydrodynamic and water quality lake Model (CE-QUAL-W2), and a\nhydro-geo-chemical model (PHREEQC).\n[PITLAKQ](\"https://www.pitlakq.com/\") is open source.\nIt has been applied world wide.\nI used it for pit lakes in Germany, Australia, and Canada.\nOthers have used it in many other countries of the world.\n\n### Coupling of a river flood model and a groundwater model\n\nI have been involved in a research project that couples a river model, a sewer\npipeline model and groundwater model for the river Elbe in the city of Dresden,\nGermany.\nI was responsible for the coupling of the river model and the groundwater\nmodel.\n\n### Rainfall runoff model -- groundwater model\n\nI implemented a coupling of a rainfall runoff model (ArcEGMO) and a groundwater\nmodel (PCGEOFIM) for a watershed in Germany.\n\n### Density-driven flow in groundwater and lake\n\nI coupled a density-driven groundwater flow and transport model (MODMST) to\nPITLAKQ.\nThis was used for a long-term simulation of a sub-aquatic landfill,\ni.e. a lake over a deposit of mining waste.\n\n###  MODFLOW with dynamic boundary conditions - pymf6\n\nI am the developer of [pymf6](\"https://pymf6.readthedocs.io/en/latest/\")\nthat allows to interact with MODFLOW 6 via Python at runtime.\nThis can be used to implement dynamic boundary conditions.\nExamples are:\n\n- water-level-controlled wells that dynamically adjust their pumping rates\n  based  on simulated water levels in the aquifer\n- dynamic values of the resistance of the colmation layer at the river bottom\n  that depend on the flow direction between river and aquifer\n- technical heat boundary conditions in urban settings such as building\n  basements and tunnels\n\n### MODFLOW 6 with AEM\n\nI coupled an Analytic Element Model (AEM)\n[TTim](\"https://ttim.readthedocs.io/en/stable/index.html\") with MODFLOW 6\nvia [pymf6](\"https://pymf6.readthedocs.io/en/latest/\").\nThis allows to combine the grid-based approach of MODFLOW with the analytic,\ngrid-less approach of AEMs.\n\n### MODFLOW 6 with PHREEQC -- rtmf6\n\nI coupled MODFLOW 6 with the geochemical model PHREEQC via\n[PhreeqPy](\"https://www.phreeqpy.com/\")using\n[PhreeqcRM](\"http://github.com/usgs-coupled/phreeqcrm\").\nI am the author of PhreeqPy.\nThe result is [rtmf6](\"https://www.rtmf6.com/\").", "public_name": "Mike M\u00fcller", "guid": "83509971-e18d-5ad6-843b-373fc98d3359", "url": "https://pretalx.com/euroscipy-2026/speaker/9KSJ3K/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/SVL9NV/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/SVL9NV/", "attachments": []}, {"guid": "31656069-12f8-5861-a277-925b133756e5", "code": "QAUJYS", "id": 92171, "logo": null, "date": "2026-07-22T11:00:00+02:00", "start": "11:00", "end": "2026-07-22T12:30:00+02:00", "duration": "01:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-92171-developing-iot-sensors-with-micropython", "url": "https://pretalx.com/euroscipy-2026/talk/QAUJYS/", "title": "Developing IoT sensors with MicroPython", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Tutorial", "language": "en", "abstract": "In this workshop, you will create practical internet-connected sensors with MicroPython. We will cover the basics of setting up the development environment, both for developing on PC and deploying/developing on a microcontroller device.\n\nTargeted towards those that are already comfortable programming in Python, but that have little exposure to embedded/hardware/electronics.\n\nWe will provide some MicroPython-capable hardware to develop against, pre-flashed with MicroPython. You may need to sit together in pairs or small groups for the on-device part.\n\n#### Prerequisites\nParticipants must bring:\n\n- Laptop with Linux/MacOS/Windows\n- Have Python 3.12+ with virtualenv support installed\n- If no USB Type-A on your laptop: USB-C to USB Type A adapter", "description": "Materials: https://github.com/jonnor/micropython-iot-sensors-course\n\n## Section 1: Basics \u2014 Running in Simulator (Wokwi)\n\n1. Introduction \u2014 Microcontroller / MicroPython / Wokwi\n2. Analog and Digital GPIO\n3. Concurrency with Asyncio\n4. Digital Bus (I2C)\n5. Talk to Servers using HTTP Client\n6. IoT Networks using MQTT\n\n## Section 2: Running on Device (RPi Pico)\n\n1. Deploying on Device with mpremote\n2. Standalone IoT Device with HTTP Server and WebUI\n\n## Section 3: Running MicroPython on PC\n\n1. Install & Run MicroPython on Linux/macOS/Windows\n\n## Section 4: Advanced Topics (Self Study)\n\n1. Installing MicroPython on Device (ESP32, RP2)\n2. Efficient Code \u2014 JIT Decorators, Inline Assembler, C Modules\n3. DSP and Machine Learning with emlearn-micropython\n4. MicroPython for Embedded Linux", "recording_license": "", "do_not_record": false, "persons": [{"code": "R7VPYA", "name": "Jon Nordby", "avatar": null, "biography": "Jon is a Machine Learning Engineer specialized in IoT systems. He has a Master in Data Science and a Bachelor in Electronics Engineering, and has published several papers on applied Machine Learning.\nHe has been contributing to open-source software since 2010.\n\nThese days Jon is co-founder and Head of Data Science at Soundsensing, a leading provider of condition monitoring solutions for commercial buildings and HVAC systems.\nHe is also the creator and maintainer of emlearn, an open-source Machine Learning library for microcontrollers and embedded systems.", "public_name": "Jon Nordby", "guid": "cba066a6-9301-5981-8b37-222f32db4126", "url": "https://pretalx.com/euroscipy-2026/speaker/R7VPYA/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/QAUJYS/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/QAUJYS/", "attachments": []}, {"guid": "34e95224-cdfd-5155-a15e-d85875c900b4", "code": "FL89YS", "id": 92152, "logo": null, "date": "2026-07-22T14:00:00+02:00", "start": "14:00", "end": "2026-07-22T15:30:00+02:00", "duration": "01:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-92152-from-black-to-white-boxes-interpretable-regression-with-the-trust-free-python-package", "url": "https://pretalx.com/euroscipy-2026/talk/FL89YS/", "title": "From Black to White Boxes: Interpretable Regression with the trust-free Python package", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Tutorial", "language": "en", "abstract": "Machine Learning practitioners often face a trade-off: high accuracy with complex, black-box models (like XGBoost or Random Forests) or lower accuracy with transparent models (like decision trees or linear models). **What if you didn't have to choose?**\nThis 90-minute tutorial introduces **TRUST** (**T**ransparent, **R**obust, and **U**ltra-**S**parse **T**rees), a new interpretable regression framework that combines decision trees with sparse linear models to deliver Random Forest accuracy. The algorithm is implemented in the Python package `trust-free` (available via pip install). We will demonstrate how TRUST autonomously recovers the WHO obesity threshold (BMI = 30) from raw data to inform medical risk pricing.\nBy the end, you will be able to train high-performing, interpretable regression models and generate automated, natural-language explanation reports for individual predictions and deterministic feature importance.", "description": "**Tutorial Summary and Learning Objectives**\n\nThis 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`.\n\nThe 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.\n\nBy the end of this 90-minute session, attendees will be able to:\n\n1. Successfully fit a high-accuracy, interpretable regression model using the `trust.TRUSTRegressor()` class.\n\n2. 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.\n\n3. Generate and interpret automated, natural-language explanation reports for any single prediction using the powerful `.explain()` method.\n\n4. Use the unique `.compare()` method to contrast two observations head-to-head, immediately highlighting the features responsible for prediction differences.\n\n**Prerequisites and Setup**\n\n- **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).\n- **Required Knowledge**: Intermediate Python (familiarity with `pandas`, `numpy`, `scikit-learn`, and Jupyter notebooks) and basic knowledge of regression concepts (R\u00b2, feature importance, cross-validation). \n- **Required Software**: Attendees should ideally have the following installed prior to the tutorial:\n  - Python 3.11 or 3.12\n  - The `trust-free` package (`pip install trust-free`)\n  - Jupyter Notebook or similar notebook environment.\n- **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.\n- **Dataset**: We will use a pre-cleaned, publicly available regression dataset (the famous Medical Insurance Charges dataset).\n\n**90-Minute Detailed Outline**\n\nThis workshop is structured with a strong emphasis on practical application, dedicating approximately 70% of the time to live coding and guided exercises.\n\n- **[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.\n- **[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.\n- **[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.\n- **[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.\n- **[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.\n- **[75-90 min] Wrap-up and Q&A**: Summary of key takeaways and resources for further exploration. Final Q&A.", "recording_license": "", "do_not_record": false, "persons": [{"code": "DDHUTN", "name": "Albert Dorador", "avatar": null, "biography": "**Albert Dorador** is an Adjunct Professor of Mathematics (**Universitat Pompeu Fabra**)  and Statistics (**BarcelonaTech**), and leads a Research Lab focused on the development of cutting edge, inherently interpretable machine learning models for tabular data (**Whitebox Lab**). He holds a PhD in Statistics from the **University of Wisconsin\u2013Madison** and previously served at the **European Central Bank**, specializing in financial risk management and machine learning applications. Albert is the creator of the **TRUST** and **Renet** algorithms and the maintainer of the `trust-free` Python library. His work focuses on the intersection of high-performance statisical modeling and auditable machine learning for high-stakes regulatory environments.", "public_name": "Albert Dorador", "guid": "b528cbb9-64a3-528d-969e-3a6ec772ec0f", "url": "https://pretalx.com/euroscipy-2026/speaker/DDHUTN/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/FL89YS/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/FL89YS/", "attachments": []}, {"guid": "26c06c06-acb4-55a5-8e98-31abd0ab70bd", "code": "Y7YM3G", "id": 92966, "logo": null, "date": "2026-07-22T16:00:00+02:00", "start": "16:00", "end": "2026-07-22T17:30:00+02:00", "duration": "01:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-92966-same-recipe-different-results-fine-tuning-models-across-modalities", "url": "https://pretalx.com/euroscipy-2026/talk/Y7YM3G/", "title": "Same Recipe, Different Results: Fine-Tuning Models Across Modalities", "subtitle": "", "track": "Applied AI & LLM Technologies and Use Cases", "type": "Tutorial", "language": "en", "abstract": "The intuitions you build fine-tuning text models are surprisingly bad guides for other modalities. Training configurations that work well for language will silently degrade an image model. Dataset sizes that feel tiny for text are more than enough for adapting a visual style. And audio, despite seeming like its own world, follows an image pipeline once you transform sound into spectrograms, making what counts as a \"token\" stranger and more interesting than most people expect. The modalities share a vocabulary (fine-tuning, adapters, checkpoints) but not a playbook, and the gaps between them are where the most useful lessons live.\n\nThis talk is a practical, comparative tour of fine-tuning across four modalities: text, images, audio, and video. Rather than focusing on one, we will look at what changes as you move between them, how you prepare different data, which training strategies transfer and which don't, where the gotchas hide, and what model merging can do for you once training is done. All examples use Python and the HuggingFace ecosystem with publicly available models and datasets. Whether you are a practitioner looking to branch out beyond NLP or someone curious about what multi-modal fine-tuning looks like in practice, you will leave with a mental map of the landscape and enough pointers to start exploring on your own.", "description": "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.\n\nThis talk walks through fine-tuning across four modalities side by side, highlighting the patterns that hold and the ones that break.\n\nFor 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.\n\nFor 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.\n\nFor 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.\n\nVideo, 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.\n\nOnce 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.\n\nAcross 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.\n\nThe 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "88DYMB", "name": "Ramon Perez", "avatar": null, "biography": "Hello! I'm Ramon, a systems engineer and educator living in Sydney. I currently work at Canva on the AI Ops team within the Content and Delivery division. Previously, I was a research engineer at Menlo Labs building tools to run AI models on robots and constrained devices, and before that a Senior Product Developer at Decoded, a technology education company based in the UK where I created custom data science tools, workshops, and training programs for clients in industries ranging from retail to finance. Prior to that, I held roles at the intersection of education, data science, and research in the areas of entrepreneurship and strategy. On the personal side, I enjoy giving talks and technical workshops and have had the privilege of participating in several conferences such as PyCon, SciPy, CppNow, PyData, and countless meetup events. In my spare time, I spend as much time as possible mountain biking and exploring many of the outdoor wonders Australia has to offer.", "public_name": "Ramon Perez", "guid": "8bb2c051-6488-577f-95a7-3b5e01b59783", "url": "https://pretalx.com/euroscipy-2026/speaker/88DYMB/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/Y7YM3G/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/Y7YM3G/", "attachments": []}], "Room 2.41 (First Floor, Turing)": [{"guid": "dd26844d-5e08-5741-9e75-fb499186a238", "code": "VLTW7C", "id": 89710, "logo": null, "date": "2026-07-22T14:00:00+02:00", "start": "14:00", "end": "2026-07-22T15:30:00+02:00", "duration": "01:30", "room": "Room 2.41 (First Floor, Turing)", "slug": "euroscipy-2026-89710-introduction-to-differentiable-programming", "url": "https://pretalx.com/euroscipy-2026/talk/VLTW7C/", "title": "Introduction to Differentiable Programming", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Tutorial", "language": "en", "abstract": "Want to unlock a powerful new tool?\n\n**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.\n\nThe tutorial will give you the basic understanding and tools you need to apply differentiable programming, and have you practice with illustrative problems.", "description": "**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.\n\nDespite its great potential, it\u2019s not uncommon for developers to move along when they happen across this topic, leaving it to the \u201cML guys\u201d and repressing bad memories from calculus class. But it doesn\u2019t 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.\n\nThe tutorial will cover the basics of differentiable programming, where I\u2019ll guide you as you solve differentiable programming challenges, starting with toy problems up to simple 3D reconstruction.\n\n**You\u2019ll learn how to**:\n* Identify problems where differentiable programming is applicable\n* Formulate problems for differentiable programming\n* Monitor and debug the optimization process\n\n*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.\n\n*Is this tutorial just for ML people*? Absolutely not! Differentiable programming has applications beyond the world of ML, and you don\u2019t need to know fancy math to use it.", "recording_license": "", "do_not_record": false, "persons": [{"code": "VJCNSR", "name": "Daniel Anderson", "avatar": null, "biography": "Hi! I'm Daniel, a machine learning research engineer from Israel.\n\nI love data and optimization, and had the opportunity to work on a variety of interesting problems, from analyzing brain signals to video-based 3D reconstruction.\n\nI'm also fascinated with learning, and love teaching and creating interactive learning experiences.\n\nI hold a B.Sc. in computer science from the Open University of Israel, and an M.Sc. in machine learning and data science from Reichman University, Israel.\n\nI love music, the outdoors, and playing with my cat.\n\nYou can [check out my blog](https://andersource.dev/) to see what I'm passionate about.", "public_name": "Daniel Anderson", "guid": "174de956-117f-583c-8ad0-97976ab02057", "url": "https://pretalx.com/euroscipy-2026/speaker/VJCNSR/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/VLTW7C/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/VLTW7C/", "attachments": []}]}}, {"index": 6, "date": "2026-07-23", "day_start": "2026-07-23T04:00:00+02:00", "day_end": "2026-07-24T03:59:00+02:00", "rooms": {"Room 1.38 (Ground Floor, Turing)": [{"guid": "2934a367-bdf0-5453-8a5b-199fc6b4355d", "code": "H9UDLT", "id": 95365, "logo": null, "date": "2026-07-23T09:00:00+02:00", "start": "09:00", "end": "2026-07-23T10:30:00+02:00", "duration": "01:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-95365-a-hands-on-introduction-to-mechanistic-interpretability", "url": "https://pretalx.com/euroscipy-2026/talk/H9UDLT/", "title": "A Hands-On Introduction to Mechanistic Interpretability", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Tutorial", "language": "en", "abstract": "Large language models (LLMs) have become central to modern scientific computing, yet for most practitioners they remain opaque systems - input goes in, text comes out, and the internal mechanism is a mystery. Mechanistic interpretability (MI) is the emerging discipline of reverse-engineering what specific components of a neural network actually *do*.\nUsing Andrej Karpathy's `microgpt` - a fully self-contained, 200-line, dependency-free GPT implementation in pure Python - as our subject, we systematically dissect what a trained language model has learned. No PyTorch, no specialised ML frameworks: just the familiar tools applied to a genuinely novel problem.\n\nThe model is tiny by design: 4,192 parameters, a 27-token vocabulary (a\u2013z + a special token), trained on 32,000 names in roughly one minute on a laptop. This makes it the ideal subject for interpretability work - every attention weight is inspectable, every embedding printable, every head ablatable. The scientific question driving the tutorial is: *\"What has this model actually learned about the structure of names?\"*", "description": "We work through four concrete investigations:\n* We extract the token embedding matrix and apply PCA to ask whether vowels and consonants form geometrically distinct clusters \u2014 testing the hypothesis that the model has learned something about phonetic structure purely from next-character prediction. \n* 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.\n* We perform systematic head ablation \u2014 zeroing individual attention heads and measuring loss change \u2014 to identify which heads are load-bearing and which are redundant.\n* 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.\n\nParticipants 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "9B7HES", "name": "Vasu Sharma", "avatar": null, "biography": "- Currently interested in AI Safety and Alignment Research | Writes at https://permutedsense.substack.com/\n- Open source and privacy-preserving tools enthusiast\n\nPrevious experience working as a data scientist on varied business propositions ranging from detecting scientific fraud in publishing, supply chain optimization, customer attrition, upselling/cross-selling card products, web personalization and customer-merchant affinity.", "public_name": "Vasu Sharma", "guid": "ef71aa04-d0be-5c5f-9481-942cf1c35587", "url": "https://pretalx.com/euroscipy-2026/speaker/9B7HES/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/H9UDLT/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/H9UDLT/", "attachments": []}, {"guid": "50eb6f3e-b1a4-5161-8074-c0a10e805731", "code": "8TC88B", "id": 92207, "logo": null, "date": "2026-07-23T11:00:00+02:00", "start": "11:00", "end": "2026-07-23T12:30:00+02:00", "duration": "01:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-92207-gluing-scipy-numba-and-pint-to-bridge-high-performance-with-maintainability", "url": "https://pretalx.com/euroscipy-2026/talk/8TC88B/", "title": "Gluing SciPy, Numba, and Pint to Bridge High Performance with Maintainability", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Tutorial", "language": "en", "abstract": "Python excels as a glue language. This tutorial will demonstrate how to harness this strength by combining Fortran-implemented number-crunching (SciPy.odeint), object-oriented dimensional analysis for physical-unit-aware code (Pint), and just-in-time compilation (Numba). The result: a lightning-fast, bug-proof Pythonic codebase for scientific computing.", "description": "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\u2019ll also explore how Pint handles unit conversions and automatic plot axis labeling. The key challenge we\u2019ll 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!", "recording_license": "", "do_not_record": false, "persons": [{"code": "VKUTRW", "name": "Sylwester Arabas", "avatar": null, "biography": "I lead the [open-atmos-krk](https://open-atmos-krk.github.io/) research software engineering team at AGH University in Krakow, where we develop and maintain several Python packages, including [Numba-MPI](https://pypi.org/p/numba-mpi), [PySDM](https://pypi.org/p/PySDM), [PyMPDATA](https://pypi.org/p/PyMPDATA), and [PyPartMC](https://pypi.org/p/PyPartMC). Before joining AGH, I worked as a postdoc at the University of Illinois Urbana-Champaign and at Jagiellonian University. During a three-year break from academia, I worked as a quant-dev in the financial sector. I completed my MSc and PhD in physics at the University of Warsaw.", "public_name": "Sylwester Arabas", "guid": "e68632a0-6050-50fd-95aa-3d0c19f0b943", "url": "https://pretalx.com/euroscipy-2026/speaker/VKUTRW/"}, {"code": "YRTFAZ", "name": "Kamil Kania", "avatar": null, "biography": null, "public_name": "Kamil Kania", "guid": "6fd9cdb9-70bf-5457-8441-20476fbf1ec7", "url": "https://pretalx.com/euroscipy-2026/speaker/YRTFAZ/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/8TC88B/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/8TC88B/", "attachments": []}, {"guid": "beb9a1bd-fae2-5cfb-bdce-d3f1915e904f", "code": "AYPWY3", "id": 92224, "logo": null, "date": "2026-07-23T14:00:00+02:00", "start": "14:00", "end": "2026-07-23T15:30:00+02:00", "duration": "01:30", "room": "Room 1.38 (Ground Floor, Turing)", "slug": "euroscipy-2026-92224-version-everything-from-chaos-to-order-in-reproducible-python-projects", "url": "https://pretalx.com/euroscipy-2026/talk/AYPWY3/", "title": "Version Everything: From Chaos to Order in Reproducible Python Projects", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Tutorial", "language": "en", "abstract": "Your analysis works perfectly on your laptop. Three weeks later, it breaks on the server. Your colleague can\u2019t run your code nor reproduce your results. The client\u2019s environment throws mysterious errors. Sound familiar?\n\nThis hands-on workshop teaches you to build reproducible workflows using a practical approach that addresses real challenges teams face when sharing code, collaborating on research, or deploying data pipelines.\n\nYou\u2019ll learn to:\n\n- Lock dependencies and manage isolated Python environments\n- Version control your code and your data\n- Externalize parameters using configuration files\n- Containerize your application for consistent deployment\n- Apply collaboration practices that scale with your team", "description": "The workshop is ideal for data scientists, researchers, and Python developers with intermediate experience who are tired of \u201cworks on my machine\u201d syndrome. You\u2019ll 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.\n\nStarting with a messy but working data analysis project, we\u2019ll systematically add reproducibility layers through guided coding exercises.\n\nModules:\n- Modern Dependency Management (10 min): Creating lock files, managing Python versions\n- Code & Configuration Versioning (30 min): Git for source code, configuration files for parameters\n- Data Pipeline Versioning (30 min): DVC setup, pipeline definitions, experiment tracking\n- Hidden Reproducibility Challenges (10 min): Randomness and human error\n- Production Deployment (10 min): Containerization, artifact registries, deployment reproducibility\n\nThe workshop is ideal for data scientists, researchers, and Python developers with intermediate experience who are tired of \u201cworks on my machine\u201d syndrome.\n\nPrerequisites:\n- A laptop with admin privileges to install tooling\n- Basic knowledge of Python syntax and the command line", "recording_license": "", "do_not_record": false, "persons": [{"code": "GQ3XLV", "name": "Aris Nivorlis", "avatar": null, "biography": "Aris Nivorlis\u202fis a researcher geophysicist and data steward at Deltares, where he uses data and tooling to answer complex questions about the subsurface. \nHe is passionate about promoting good practices in data management and scientific coding, helping teams build sustainable and reproducible workflows. \nOutside of work, Aris is actively involved in the European Python community, contributing to the organization and support of conferences and community initiatives. When he's not at his computer, you\u2019ll likely find him dancing salsa.", "public_name": "Aris Nivorlis", "guid": "178ba5c1-fc02-52fd-8eda-21885fc35790", "url": "https://pretalx.com/euroscipy-2026/speaker/GQ3XLV/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/AYPWY3/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/AYPWY3/", "attachments": []}], "Room 1.19 (Ground Floor, Shannon)": [{"guid": "5d469689-93a8-59b6-be1f-33ac781f7742", "code": "TRFRMH", "id": 92165, "logo": null, "date": "2026-07-23T09:00:00+02:00", "start": "09:00", "end": "2026-07-23T10:30:00+02:00", "duration": "01:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-92165-napari-explorative-visualization-and-workflow-building-for-scientific-data-analysis", "url": "https://pretalx.com/euroscipy-2026/talk/TRFRMH/", "title": "napari: explorative visualization and workflow building for scientific data analysis", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Tutorial", "language": "en", "abstract": "If you work with scientific data, chances are that visualization is one of your strongest tools and biggest time sinks. Whether you're dealing with images from microscopes or telescopes, complex surface reconstructions, 3D point clouds, or n-dimensional feature embeddings from neural networks, some requirements are always the same: _performance_, _interactivity_, and _extensibility_.\nnapari is a Python library for the visualization and annotation of scientific data that focuses on addressing these needs, staying cross-field and un-specialized at the core, while providing an easy way to develop powerful specialized plugins.\nIn this tutorial, we will learn the basics of interacting with napari and its features and how to use napari to effectively navigate n-dimensional data. Armed with this knowledge, we will simulate a typical exploratory approach to developing a new image processing workflow in Python and converting it to an easily shearable napari plugin.", "description": "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.\n\nIf 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.\n\nTo 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\u2019t necessarily need to be familiar with how these tools and methods work - it\u2019s enough to know that they are out there!\n\n### Introduction to napari (~20-30 min)\n\nWe 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.\n\n### Exploratory analysis (~45-60 min)\n\nIn 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.\n\n### Making a plugin (~10-15 min)\n\nTo 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.", "recording_license": "", "do_not_record": false, "persons": [{"code": "CWYMGX", "name": "Lorenzo Gaifas", "avatar": null, "biography": "I joined the napari community during my PhD in structural biology, where I used and contributed to napari regularly, until I was invited to join the core team. I now work full time on napari as an independent contractor, improving and developing many of the features that I used or introduced during my PhD.", "public_name": "Lorenzo Gaifas", "guid": "08eac9ea-41bf-5bc5-b566-eba723432868", "url": "https://pretalx.com/euroscipy-2026/speaker/CWYMGX/"}, {"code": "7V3CXP", "name": "Grzegorz Bokota", "avatar": null, "biography": "I'm napari (napari.org) core team member and Assistant Professor on University of Warsaw, \n\nMy background are Math and Computer Science. \nAs a daily task in napari project I focus on debug edge case, improving code efficiency and API to allow user focus on solving problems, not reinventing wheels.", "public_name": "Grzegorz Bokota", "guid": "0408dba1-0163-5e43-9c22-deada65e8fd2", "url": "https://pretalx.com/euroscipy-2026/speaker/7V3CXP/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/TRFRMH/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/TRFRMH/", "attachments": []}, {"guid": "9e4915f9-b126-5add-9f55-9dc55a37326f", "code": "ZFSAVF", "id": 103165, "logo": null, "date": "2026-07-23T11:00:00+02:00", "start": "11:00", "end": "2026-07-23T12:30:00+02:00", "duration": "01:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-103165-introduction-to-data-science-with-python-pandas-and-polars", "url": "https://pretalx.com/euroscipy-2026/talk/ZFSAVF/", "title": "Introduction to Data Science with Python: Pandas and Polars", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Tutorial", "language": "en", "abstract": "This workshop introduces the fundamentals of data science using Python, focusing on data manipulation and exploratory analysis with the Pandas and Polars libraries. Participants will learn how to load, inspect, clean, transform, and summarize structured datasets through practical examples in Jupyter notebooks. This tutorial also highlights the similarities and differences between Pandas and Polars, providing insight into when each library is most appropriate.", "description": "This beginner-friendly tutorial provides a practical introduction to the essential tools and techniques used in Python-based data science.\nThe tutorial will cover:\n\n- An overview of the Python data science ecosystem\n- Loading datasets using Pandas and Polars\n- Inspecting data structures and understanding data types\n- Cleaning and preparing data for analysis\n- Selecting, filtering, and transforming data\n- Computing summary statistics and performing basic aggregations\n- A brief comparison of Pandas and Polars, including syntax and performance considerations\n\nThe session is prepared for participants to follow along in Jupyter notebooks and complete short exercises throughout the tutorial.", "recording_license": "", "do_not_record": false, "persons": [{"code": "HDPEEL", "name": "Justyna Szyd\u0142owska-Samsel", "avatar": null, "biography": null, "public_name": "Justyna Szyd\u0142owska-Samsel", "guid": "9d511946-d767-5bfc-a538-769ce67e8ce7", "url": "https://pretalx.com/euroscipy-2026/speaker/HDPEEL/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/ZFSAVF/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/ZFSAVF/", "attachments": []}, {"guid": "3c5b738a-85a9-507f-9fc6-e85258068075", "code": "LL8N7L", "id": 92193, "logo": null, "date": "2026-07-23T14:00:00+02:00", "start": "14:00", "end": "2026-07-23T15:30:00+02:00", "duration": "01:30", "room": "Room 1.19 (Ground Floor, Shannon)", "slug": "euroscipy-2026-92193-deploying-and-debugging-gpu-accelerated-python-workloads", "url": "https://pretalx.com/euroscipy-2026/talk/LL8N7L/", "title": "Deploying and debugging GPU accelerated Python workloads", "subtitle": "", "track": "Computational Tools and Scientific Python Infrastructure", "type": "Tutorial", "language": "en", "abstract": "Leveraging GPU acceleration is now a common necessity for scaling Python projects. NVIDIA GPUs offer unmatched speed and efficiency for data processing and model training, significantly reducing the time and cost associated with these tasks. GPU acceleration is already baked into many projects, or available via plugins. You can use PyData libraries including pandas, polars and networkx without needing to rewrite your code to get the benefits of GPU acceleration. \n\nHowever, integrating GPUs into our workflow can be a new challenge where we need to learn about installation, dependency management, and deployment in the Python ecosystem. When writing code, we also need to monitor performance, leverage hardware effectively, and debug when things go wrong\n\nThis is where RAPIDS and its tooling ecosystem comes to the rescue. RAPIDS, is a collection of open source software libraries to execute end-to-end data pipelines on NVIDIA GPUs using familiar PyData APIs.\n\nIn this tutorial we will cover:\n- Answers to questions like: \u201cWhere do I get a GPU?\u201d, \u201cHow do I run a container on a VM with a GPU?\u201d, \u201cHow do I install GPU packages into an existing environment?\u201d, \u201cWhat if I use uv pip?\u201d, \u201cWhat about conda? \u201das well as follow along examples to get a GPU up and running.\n- Troubleshooting and monitoring:  Examples of performance analysis, diagnostics, and debugging. Showcasing of diagnostic tools like nvdashboard, nvtop, nsys, pynvml, etc.", "description": "## Audience\nThis 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.\n\nTo 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.\n\nKey takeaways for participants will be:\n\n- An understanding of the GPU Python software stack from driver through core libraries to high-level Python libraries\n- How they can use their preferring tooling and package managers to install all the components they need\n- How to monitor their GPUs and understand how well they are using their hardware\n- How to attach debuggers to their GPU code or record traces and profiles for debugging later\n\n## Notes\nThis 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.\n\n## Format\nIn 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.\n\nWe 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.\n\n## Internet requirements\nParticipants 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.\n\n## Outline\n\n- 0 mins- Intro and Setup\n  - Introduce common libraries and tools where GPUs are leveraged in Python\n  - Show some quick demos of how to run Python code that uses the GPU\n- 15 mins - How do I get a GPU?\n  - Give participants access to cloud GPU resources\n  - While the VMs start we will talk about alternatives\n  - Everyone has their own tool and vendor preferences but the principles are the same\n- 30 mins - An exploration of Python package managers\n  - pip, conda, uv and pixi are just some of the popular package managers\n  - You can install GPU software with all of them, but there are differences and nuances\n  - Participants will set up various GPU Python environments with these tools to get an understanding of the need to know differences\n- 50 mins - Monitoring\n  - Running GPU accelerated Python code is just like running normal code\n  - We will see how to verify our code really is being GPU accelerated\n  - Participants will run examples and gather metrics on utilization and memory use with various tools\n- 70 mins - Debugging\n  - Once you run some code you need to understand how it is performing\n  - When your code crashes you need to debug and inspect what went wrong\n  - GPU libraries can abstract complexity away, making them harder to debug\n  - Participants will install and use various debugging tools to explore how to debug GPU accelerated code examples\n- 90 mins - Close", "recording_license": "", "do_not_record": false, "persons": [{"code": "3ZK9JJ", "name": "Jacob Tomlinson", "avatar": null, "biography": "Jacob Tomlinson is a senior Python software engineer at NVIDIA with a focus on deployment tooling for distributed systems. His work involves maintaining open source projects including RAPIDS and Dask. RAPIDS is a suite of GPU accelerated open source Python tools which mimic APIs from the PyData stack including those of Numpy, Pandas and SciKit-Learn. Dask provides advanced parallelism for analytics with out-of-core computation, lazy evaluation and distributed execution of the PyData stack. He also tinkers with the open source Kubernetes Python framework kr8s in his spare time. Jacob volunteers with the local tech community group Tech Exeter and lives in Exeter, UK.", "public_name": "Jacob Tomlinson", "guid": "7d5794a8-e43e-58a6-9a19-8751d101fde1", "url": "https://pretalx.com/euroscipy-2026/speaker/3ZK9JJ/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/LL8N7L/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/LL8N7L/", "attachments": []}], "Room 2.41 (First Floor, Turing)": [{"guid": "b9e28c12-9742-5f82-a951-a9c8f5fc7d46", "code": "AMHGUK", "id": 92563, "logo": null, "date": "2026-07-23T14:00:00+02:00", "start": "14:00", "end": "2026-07-23T15:30:00+02:00", "duration": "01:30", "room": "Room 2.41 (First Floor, Turing)", "slug": "euroscipy-2026-92563-microwave-image-processing-exploring-realms-of-earth-through-spaceborne-radars-using-python", "url": "https://pretalx.com/euroscipy-2026/talk/AMHGUK/", "title": "Microwave Image Processing: Exploring realms of Earth through spaceborne Radars using Python", "subtitle": "", "track": "Environmental and Earth Sciences", "type": "Tutorial", "language": "en", "abstract": "Remote Sensing has proved to be an important tool in monitoring our earth's ecosystem. Satellite imaging is a vital part of Remote Sensing. Predominantly, Satellite Imaging of the earth has been done in the optical domain and optical Images serve the majority of purpose for earth monitoring. But, these satellites do not have all-weather acquisition capability and this lacuna is filled by the satellite sensors working in the Microwave domain of the Electromagnetic spectrum. Synthetic Aperture Radar(SAR) is an Imaging Radar that acquires images of a particular area on Earth in the microwave region of electro-magnetic spectrum. This workshop deals with the processing of SAR Images and how these images can be beneficial in a variety of geographical applications.", "description": "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.\n\nPost  workshop, the audience will be :\n\ni) Able to understand the acquisition of SAR imagery.\n\nii) Able to understand the types of datasets utilized in remote sensing\n\niii) Able to use the GDAL library to perform operations on images\n\niv) Able to efficiently process SAR imagery using Python\n\nv) Able to draw a roadmap in order to utilize SAR imagery for various geographic applications\n\nOutline\n\nThe workshop will be divided into the following sub-sessions :\n\nSub-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.\n\nSub-Session-2: Pythonic Way to SAR Image Processing (75 minutes): This part will focus on achieving the following Key points:\n\n1) Basic utilization of GDAL, Numpy and Matplotlib Libraries for opening and visualizing Images(25 minutes)\n\n2) Codes will be developed separately for calibration for each SAR sensor(esp. Sentinel-1, Radarsat-2) from scratch.(25 minutes)\n\n3) Utilization of the codes developed in (2) for various applications such as Oceanography, Forestry, etc.(25 minutes)\n\nDatasets: 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/\n\nConduct of the workshop : The workshop will be conducted through the means of Jupyter Notebooks.", "recording_license": "", "do_not_record": false, "persons": [{"code": "YKEDNV", "name": "Shubham Sharma", "avatar": null, "biography": "Shubham Sharma is a Senior Data Scientist with more than ten years of experience at the convergence of Remote Sensing, Image Processing, Computer Vision, and Deep Learning. He has been an active contributor to the open-source scientific computing ecosystem, engaging with communities through conferences such as SciPy and as a past speaker at PyCon. His work includes significant experience in Synthetic Aperture Radar (SAR) image processing, and he is deeply committed to advancing knowledge of satellite image analysis using Python within the open source community.", "public_name": "Shubham Sharma", "guid": "5b394c10-5ba2-56fc-ad7f-43a5be4daa62", "url": "https://pretalx.com/euroscipy-2026/speaker/YKEDNV/"}], "links": [], "feedback_url": "https://pretalx.com/euroscipy-2026/talk/AMHGUK/feedback/", "origin_url": "https://pretalx.com/euroscipy-2026/talk/AMHGUK/", "attachments": []}]}}]}}}