2.0 -//Pentabarf//Schedule//EN PUBLISH E7Z3VY@@pretalx.com -E7Z3VY Increase citations, ease review & collaboration – Making machine learning in research reproducible en en 20220829T083000 20220829T100000 013000

Increase citations, ease review & collaboration – Making machine learning in research reproducible

One of the tenets of science is to be reproducible. But if we always did what we’re supposed to, the world would be a better and easier place. However, there are benefits to making science reproducible that directly benefit researchers, especially in computational science and machine learning. These benefits are like the title says: - Easier review cycles - More citations - More collaboration But it goes further. Reproducibility is a marketable skill outside of academia. When we work in companies that apply data science or machine learning, these companies know that technical debt can slowly degrade a code base and in some cases like Amazon and Google, the machine learning system has to be so reproducible that we expect the entire training and deployment to work automatically on a press of a button. Technical debt is also a problem in academia, but here it is more framed in the devastating prospect of the only postdoc leaving that knows how to operate the code base. Luckily, we have a lot of work cut out for us already! These benefits, and a few others, like making iteration, and therefore frequent publication easier, do not come at a proportional cost. Most of the methods to increase code quality in machine learning projects of applied scientists are in fact fairly easy to set up and run! So how do we actually go about obtaining these goals? ## Model Evaluation Applying machine learning in an applied science context is often method work. We build a prototype model and expect want to show that this method can be applied to our specific problem. This means that we have to guarantee that the insights we glean from this application generalize to new data from the same problem set. This is why we usually import `train_test_split()` from scikit-learn to get a validation set and a test set. But in my experience, in real-world applications, this isn’t always enough. In science, we usually deal with data that has some kind of correlation in some kind of dimension. Sometimes we have geospatial data and have to account for Tobler’s Law, i.e. things that are closer to each other matter more to each other than those data points at a larger distance. Sometimes we have temporal correlations, dealing with time series, where data points closer in time may influence each other. Not taking care of proper validation, will often lead to additional review cycles in a paper submission. It might lead to a rejection of the manuscript which is bad enough. In the worst case scenario, our research might report incorrect conclusions and have to be retracted. No one wants rejections or even retractions. So we’ll go into some methods to properly evaluate machine learning models even when our data is not “independent and identically distributed”. ## Benchmarking Another common reason for rejections of machine learning papers in applied science is the lack of proper benchmarks. This section will be fairly short, as it differs from discipline to discipline. However, any time we apply a superfancy deep neural network, we need to supply a benchmark to compare the relative performance of our model to. These models should be established methods in the field and simpler machine learning methods like a linear model, support-vector machine or a random forest. ## Model Sharing Some journals will require the sharing of code or models, but even if they don’t we might benefit from it. Anytime we share a model, we give other researchers the opportunity to replicate our studies and iterate upon them. Altruistically, this advances science, which in and of itself is a noble pursuit. However, this also increases the citations of our original research, a core metric for most researchers in academia. In this section, we explore how we can export models and make our training codes reproducible. Saving a model from scikit-learn is easy enough. But what tools can we use to easily make our training code adaptable for others to import and try out that model? Specifically, I want to talk about: - Automatic Linters - Automatic Formatting - Automatic Docstrings and Documentation - Docker and containerization for ultimate reproducibility ## Testing Machine learning is very hard to test. Due to the nature of the our models, we often have soft failures in the model that are difficult to test against. Writing software tests in science, is already incredibly hard, so in this section we’ll touch on - some fairly simple tests we can implement to ensure consistency of our input data - avoid bad bugs in data loading procedures - some strategies to probe our models ## Interpretability One way to probe the models we build is to test them against the established knowledge of domain experts. In this final section, we’ll explore how to build intuitions about our machine learning model and avoid pitfalls like spurious correlations. These methods for model interpretability increase our trust into models, but they can also serve as an additional level of reproducibility in our research and a valuable research artefact that can be discussed in a publication. This part of the tutorial will also go into some considerations why the feature importance of tree-based methods can serve as a start but often shouldn’t be used as the sole source of truth regarding feature interpretation of our applied research. This section will introduce tools like `shap`, discuss feature importance, and manual inspection of models. ## Ablation Studies Finally, the gold standard in building complex machine learning models is proving that each constituent part of the model contributes something to the proposed solution. Ablation studies serve to dissect machine learning models and evaluate their impact. In this section, we’ll finally discuss how to present complex machine learning models in publications and ensure the viability of each part we engineered to solve our particular problem set. ## Conclusion Overall, this tutorial is aimed at applied scientists that want to explore machine learning solutions for their problems. This tutorial focuses on a collection of “easy wins” that scientists can implement in their research to avoid catastrophic failures and increase reproducibility with all its benefits. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/E7Z3VY/ HS 120 Jesper Dramsch PUBLISH TXYGUK@@pretalx.com -TXYGUK Time Series Forecasting with scikit-learn's Quantile Gradient Boosted Regression Trees en en 20220829T103000 20220829T120000 013000

Time Series Forecasting with scikit-learn's Quantile Gradient Boosted Regression Trees

This tutorial is intended for an audience with some familiarity with data science tools and machine learning concepts. It will start from practical considerations on how to manipulate the data and fit simple yet powerful models and progressively move to more advanced considerations on model evaluation. The main focus is to show how to **cast a time series forecasting problem into a supervised machine learning problem** (non-linear regression) using basic pandas-based feature engineering, time series aware cross-validation and highlighting the impact of the choice of the loss function of gradient boosting models. We will compare this forecasting to a baseline that only leverages instantaneous contextual variables as predictors using scikit-learns feature engineering tools (column transformers and pipelines) with a particular emphasis how to build **cyclic time-derived features** and categorical variables. We will then dive deeper into model evaluation assessing various performance metrics with time-series aware cross-validation. We will compare uncertainty bounds from quantile regression with conformal prediction methods from MAPIE. Finally we will explore how to deal with the auto-regressive setting to predict forecast for a multi-step horizon with `sktime`. The tutorial will be available as a Jupyter notebook and the audience will be encouraged to develop there how intuitions by experimenting interactively with the teaching material. If time allows, we will also compare this approach with alternative solutions based on neural networks or linear models trained on rich spline-based features. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/TXYGUK/ HS 120 Olivier Grisel PUBLISH UWGJXA@@pretalx.com -UWGJXA Evaluating your machine learning models: beyond the basics en en 20220829T133000 20220829T150000 013000

Evaluating your machine learning models: beyond the basics

Model evaluation is a crucial aspect of machine-learning, to choose the best model, or to decide if a given model is good-enough for production. This tutorial will give didactic introductions to the various statistical aspects of model evaluation: what aspects of model prediction are important to capture, and how different metrics available in scikit-learn captures them. How to devise a model-evaluation procedure that is best suited to select the best model, or control that a model is suited for usage. This tutorial goes beyond mere application of scikit-learn and we expect even experts to learn useful considerations. The tutorial will be loosely based on the following preprint https://hal.archives-ouvertes.fr/hal-03682454, but with code examples for each important concept. A tentative outline is as follows: ### Performance metrics #### Metrics for classification - Binary classification - Confusion matrix - Simple summaries and their pitfalls - Probability of detection given true class, or vice versa? - Summary metrics for low prevalence - Metrics for shifts in prevalence - Multi-threshold metrics - Confidence scores and calibration - Multi-class classification - Adapting binary metrics to multi-class settings - Multilabel classification #### Metrics for regression - R2 score - Absolute error measures - Assessing the distribution of errors ### Evaluation strategies #### Evaluating a learning procedure - Cross-validation strategies - Driving model choices: nested cross-validation - Statistical testing - Sources of variance - Accounting for benchmarking variance #### Evaluating generalization to an external population - The notion of external validity - Confidence intervals for external validation PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/UWGJXA/ HS 120 Gaël Varoquaux Arturo Amor PUBLISH HYZRBT@@pretalx.com -HYZRBT Introduction to Audio & Speech Recognition en en 20220829T153000 20220829T170000 013000

Introduction to Audio & Speech Recognition

Unlike general Machine Learning problems where we either classify i.e. segregate a data point into a pre-defined class or regress around a continuous variable, audio related problems can be slightly more complex. Wherein, we either go from an audio representation to a text representation (ASR) or separate different layers of audio (Diarization) and so on. This tutorial will not only help you build applications like these but also unpack the science behind them using a code-first approach. Every step of the way we’ll first write and run some code and then take a step back and unpack it all till it makes sense. We’ll make science *fun* again :) The tutorial will be divided into 3 key sections: 1. Read, Manipulate & Visualize Audio data 2. Build your very own ASR system (using pre-trained models like Wav2Vec2.0) & deploy it 3. Create an Audio Classification pipeline & infer the model for other downstream audio tasks At the end of the tutorial, you’ll develop strong intuition about Audio data and learn how to leverage large pre-trained backbone models for downstream tasks. You’ll also learn how to create quick demos to test and share your models. Libraries: HuggingFace, SpeechBrain, PyTorch & Librosa PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/HYZRBT/ HS 120 Vaibhav Srivastav PUBLISH W7WDKW@@pretalx.com -W7WDKW Getting started with JupyterLab en en 20220829T083000 20220829T100000 013000

Getting started with JupyterLab

# Outline ## Introduction * Terminology: JupyterLab, Notebook, IPython (10 min) * Notebook approach - cells, code, markdown and more (15 min) ## Tools * Help system and history (10 min) * Magic functions basics (15 min) ## Development * Runtime measurements and profiling (20 min) * Exceptions and debugging (20 min) The tutorial will be hands on. While the students will receive a comprehensive PDF with all course content, I will not distribute pre-filled Notebooks. Instead, I will start with a blank Notebook for each topic and develop the content step-by-step. The participants are encouraged to type along. My typing speed is usually appropriate and allows participants to follow. In addition, the supplied PDF contains all needed code and commands to get back on track, if I should be too fast. I also explicitly ask for feedback if I am too fast or things are unclear. I encourage questions at any time. In fact, questions and my answers are often an important part of my teaching, making the learning experience much more lively and typically more useful. ### Software Requirements You need to have Python and JupyterLab installed. I will use Python 3.10. Older versions such as 3.8. or 3.9 should work too. If you use Anaconda, you should be all set. Otherwise, if you use conda install with `conda install -c conda-forge jupyterlab` (or use `mamba` instead of `conda`); if you use `pip` install with `pip install jupyterlab`. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/W7WDKW/ HS 118 Mike Müller PUBLISH SSZFWQ@@pretalx.com -SSZFWQ Introduction to Python for scientific programming en en 20220829T103000 20220829T120000 013000

Introduction to Python for scientific programming

This tutorial will provide an introduction to Python intended for beginners. It will notably introduce the following aspects: - built-in types - controls flow (i.e. conditions, loops, etc.) - built-in functions - basic Python class We introduce here the Python language. Only the bare minimum necessary for getting started with Numpy and Scipy is addressed here. To learn more about the language, consider going through the excellent tutorial https://docs.python.org/tutorial. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/SSZFWQ/ HS 118 Mojdeh Rastgoo PUBLISH JNXQPB@@pretalx.com -JNXQPB Introduction to NumPy en en 20220829T133000 20220829T150000 013000

Introduction to NumPy

This tutorial will provide an introduction to the NumPy library intended for beginners. You are encouraged to type along with me. For this you bring your laptop with a Firefox 90+ or Chromium 89+ installed. We will work through this repository: https://github.com/maikia/numpy-demo NumPy is the fundamental package for scientific computing in Python. It is a Python library that provides a multidimensional array object, various derived objects (such as masked arrays and matrices), and an assortment of routines for fast operations on arrays, including mathematical, logical, shape manipulation, sorting, selecting, I/O, discrete Fourier transforms, basic linear algebra, basic statistical operations, random simulation and much more. This tutorial will notably introduce the following aspects: - n-dimensional arrays (`ndarray`) - indexing of `ndarray` - operations on `ndarray` PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/JNXQPB/ HS 118 Maria Teleńczuk PUBLISH KD3D7W@@pretalx.com -KD3D7W Introduction to pandas en en 20220829T153000 20220829T170000 013000

Introduction to pandas

You'll learn how to convert your existing Python lists and dictionaries to DataFrames and how to read data from files into DataFrames. pandas provides powerful methods for transforming data, and you'll get experience with these in hands-on exercises. The tutorial covers the following topics: - DataFrames as Panels of Data - Create DataFrames - Work With Tidy Data - Transform DataFrames - Share Results and Insights The workshop consists of 90 minutes of live code demonstrations and hands-on exercises. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/KD3D7W/ HS 118 Geir Arne Hjelle PUBLISH RRQVRN@@pretalx.com -RRQVRN Introduction to PyTorch en en 20220830T083000 20220830T100000 013000

Introduction to PyTorch

In this tutorial we will go through the main features of the `PyTorch` framework for Deep Learning. We will start by learning how to build a neural network from the ground up, deep diving into `torch.tensor`, `Dataset` and `optimisers`. We will analyse data cases from different domains (e.g. _numerical_, _images_), introducing different neural network layers and architecture. Last but not least, a few tips from a pure Data science-y perspective will be shared, to appreciate the wonderful integration PyTorch has with the Python Data model! PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/RRQVRN/ HS 120 Valerio Maggio PUBLISH WNEGE7@@pretalx.com -WNEGE7 Introduction to geospatial data analysis with GeoPandas en en 20220830T103000 20220830T120000 013000

Introduction to geospatial data analysis with GeoPandas

This tutorial is an introduction to geospatial data analysis in Python, with a focus on tabular vector data using GeoPandas. The content focuses on introducing the participants to the different libraries to work with geospatial data and will cover munging geo-data and exploring relations over space. This includes importing data in different formats (e.g. shapefile, GeoJSON), visualizing, combining and tidying them up for analysis, and will use libraries such as pandas, geopandas, shapely, pyproj, matplotlib, folium, … Please find the material and installation instructions at https://github.com/jorisvandenbossche/geopandas-tutorial PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/WNEGE7/ HS 120 Joris Van den Bossche PUBLISH XSNHMB@@pretalx.com -XSNHMB Image processing with scikit-image en en 20220830T133000 20220830T150000 013000

Image processing with scikit-image

Image data are used in many scientific fields such as astronomy, life sciences or material sciences. This tutorial will walk you through image processing with the scikit-image library, which is the numpy-native image processing library of the scientific python ecosystem. The goal of the tutorial is to give confidence to beginners in image processing to get started processing their images with scikit-image, to understand some basic concepts of image processing and to understand how to find help and documentation to go further after the tutorial. For more advanced users, a last part will focus on performance aspects. The first hour of the tutorial will be accessible to beginners in image processing. Some experience with manipulating numpy arrays is a pre-requisite. We will first explain how to manipulate image pixels as elements of numpy arrays, and how to make basic transformation of images through numpy arrays. Then we will move to some basic concepts of digital image processing: - image histogram and contrast - image filtering: transformations of an image resulting in a new image of similar size (for example, thresholding, edge enhancement, etc.) - image segmentation: partitioning an image into several regions (objects) - measures on binary images This part will be hands-on with several exercises, and we will show how to use the scikit-image documentation to find relevant information. In the last half hour, Emma will focus on more advanced aspects and in particular will speak about performance and acceleration of image processing. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/XSNHMB/ HS 120 Emmanuelle Gouillart Deleted User PUBLISH LF777M@@pretalx.com -LF777M Network Science with Python en en 20220830T153000 20220830T170000 013000

Network Science with Python

In this workshop we will cover the basics of network theory and network thinking, then we will go over some algorithms used to analyse network data. We will take a quick detour to understand the story between linear algebra and networks. We will then jump on to some real world datasets and how to use our newly acquired skills to tackle the data problems. This will be a hands-on and interactive tutorial, so get ready to code your way till the end! By the end of the workshop you should be comfortable with working with network data using the PyData ecosystem (NetworkX, pandas, numpy!). We will roughly follow the following timeline during the workshop (30 mins each) Part A: Introduction to Graphs and the NetworkX API Part B: Graph Algorithms - Hubs: Which nodes are the important nodes in our data? - Paths: Where should I jump next to find my destination? - Structures: Who should I be friends with? Part C: Linear Algebra and Network Science - What do matrices have to do with nodes and edges? PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/LF777M/ HS 120 Mridul Seth PUBLISH ZQJPNY@@pretalx.com -ZQJPNY Introduction to SciPy en en 20220830T083000 20220830T100000 013000

Introduction to SciPy

This tutorial will provide an introduction SciPy intended for beginners. You are encouraged to type along with me. To do so, please bring your laptop with a Firefox 90+ or Chromium 89+ installed. We will work through this repository: https://github.com/Vincent-Maladiere/scipy-demo. SciPy is a collection of mathematical algorithms and convenience functions built on the NumPy extension of Python. It adds significant power to the interactive Python session by providing the user with high-level commands and classes for manipulating and visualizing data. The tutorial will introduce notably the following topics: - routines for linear algebra - optimization routines PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/ZQJPNY/ HS 118 Vincent Maladiere PUBLISH HYLCNT@@pretalx.com -HYLCNT Introduction to scikit-learn I en en 20220830T103000 20220830T120000 013000

Introduction to scikit-learn I

This tutorial will provide a beginner introduction to scikit-learn. Scikit-learn is a Python package for machine learning. This tutorial will be subdivided into three parts. First, we will present how to design a predictive modeling pipeline that deals with heterogeneous types of data. Then, we will go more into detail in the evaluation of models and the type of trade-off to consider. Finally, we will show how to tune the hyperparameters of the pipeline. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/HYLCNT/ HS 118 Arturo Amor Arkadiusz Trawiński PUBLISH GSQFSV@@pretalx.com -GSQFSV Introduction to scikit-learn II en en 20220830T133000 20220830T150000 013000

Introduction to scikit-learn II

This tutorial will provide a beginner introduction to scikit-learn. Scikit-learn is a Python package for machine learning. This tutorial will be subdivided into three parts. First, we will present how to design a predictive modeling pipeline that deals with heterogeneous types of data. Then, we will go more into detail in the evaluation of models and the type of trade-off to consider. Finally, we will show how to tune the hyperparameters of the pipeline. PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/GSQFSV/ HS 118 Arturo Amor Arkadiusz Trawiński PUBLISH UCDNLV@@pretalx.com -UCDNLV Effectively using matplotib en en 20220830T153000 20220830T170000 013000

Effectively using matplotib

Matplotlib is one of the most-used and powerful visualization libraries for python. Nevertheless, there has been and still is some confusion on how use it properly. This has a number of reasons ranging from an evolution of the API and lack of good documentation to the complexity that comes with the large feature set and flexibility. But these issues can be overcome. This tutorial will explain the main concepts and intended usage patterns of matplotlib. Knowing these, lets you effectively use high-level functions for most of the cases. But you will be able to go into the details if you need to fine-tune certain aspects of the plot. We'll also touch some nowadays discouraged ways of working from the past (you should know what not to do - even though that's still found in lots of examples on the web) and we may get a glimpse into the future. Tim Hoffmann joined the matplotlib core development team almost two years ago with the mission to make matplotlib easier to use. Requirements and set up instructions: Jupyter plus any recent (>=3.0) matplotlib version will do. To be on the safe side, you may set up a new conda environment using conda create -n using-mpl matplotlib jupyterlab pandas ipympl. Notebooks: https://github.com/timhoffm/using-matplotlib PUBLIC CONFIRMED Tutorial https://pretalx.com/euroscipy-2022/talk/UCDNLV/ HS 118 Tim Hoffmann PUBLISH 38NBJR@@pretalx.com -38NBJR JAX and Flax: Function Transformations and Neural Networks en en 20220831T090000 20220831T100000 010000

JAX and Flax: Function Transformations and Neural Networks

Modern accelerators (graphics processing units and tensor processing units) allow for high performance computing at massive scale. JAX traces computation in Python programs through the familiar numpy API, and uses XLA to compile programs that run efficiently on these accelerators. A set of composable function transformations allows for expressing versatile scientific computing with an elegant syntax. Flax provides abstractions on top of JAX that make it easy to handle weights and other states that is required for solving problems using neural networks. This talk first presents the basic JAX API that allows for computing gradients, compiling functions, or vectorizing computation. It then proceeds to cover other parts of the JAX ecosystem commonly used for neural network programming, such as basic building blocks and optimizers. PUBLIC CONFIRMED Keynote https://pretalx.com/euroscipy-2022/talk/38NBJR/ Aula Andreas Steiner PUBLISH 38L9P9@@pretalx.com -38L9P9 Interactive Image Annotation with plotly and Dash en en 20220831T103000 20220831T110000 003000

Interactive Image Annotation with plotly and Dash

Automatic image processing is a common task in many scientific and technological fields such as life sciences (with medical imaging), satellite imaging, etc. While machine learning is often used for efficient processing of such data sets, building a high-quality training set is an important task. Specialized software (such as rootpainter, ilastik) exist in different communities to build such training sets thanks to user annotations drawn on images. In this talk, I will show how to use the open-source libraries plotly and dash to build custom interactive applications for interactive image annotation, and how to combine these tools with libraries such as scikit-image or machine learning/deep learning libraries for building a whole image processing pipeline. PUBLIC CONFIRMED Guest Talk https://pretalx.com/euroscipy-2022/talk/38L9P9/ Aula Emmanuelle Gouillart PUBLISH RHYT3R@@pretalx.com -RHYT3R What is Contributor Experience? en en 20220831T110500 20220831T113500 003000

What is Contributor Experience?

In my current work as a contributor experience lead, I am supporting and growing Matplotlib’s and Pandas’ communities by organizing events, meetings, and proactive engagement with a focus on equity and inclusion of historically marginalized groups. In my talk I’ll give an introduction to this new role, the grant that supports it, and some of the work done so far… I will share takeaways for maintainers, and contributors; from simple changes that can be implemented relatively easily, to bigger topics, which one might want to learn more about, and slowly yet proactively, facilitate changes to tweak the contributor experience for a project. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/RHYT3R/ HS 120 Noa Tamir PUBLISH 7W7PPC@@pretalx.com -7W7PPC Discover Pythran through 10 code samples en en 20220831T114000 20220831T121000 003000

Discover Pythran through 10 code samples

The [pythran](https://pythran.readthedocs.io) compiler is used to speed-up generic Python scientific kernels across the world, including scipy and scikit-image ones. It has the advantage of taking pure Python code as input, with type annotations on function entry points, and generate efficient native code in exchange. But there's much more to it! Through 10 commented real-world examples taken from stackoverflow, scipy and scikit learn code base, this talk is going to present some of the technical nits Pythran has to offer: OpenMP support, SIMD instruction usage, a featurful type signature description, high-level code optimization, Python syntax sugar support, distutils integration (oops, is that even a feature?) PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/7W7PPC/ HS 120 Serge « sans » Paille PUBLISH 8XBVXQ@@pretalx.com -8XBVXQ How to increase diversity in open source communities en en 20220831T133500 20220831T135000 001500

How to increase diversity in open source communities

In this talk we’ll first examine the problems encountered by people belonging to marginalised groups in open source as well as by project maintainers with respect to contributing to and increasing the diversity of open source projects, respectively [1][2][3][4][5][6]. Building on this overview, we’ll go over what kind of actions have been taken to increase diversity in open source projects, with special focus on scientific libraries, and the effects they have had [1][6][7]. Lastly, we’ll look at ideas that are currently being tested and next steps. By the end of this talk, the audience will have a good understanding of why contributor diversity is low in open source, the efforts that have been made so far to address this problem, and what can further be done to increase the presence of underrepresented groups in technology in general, and in open source in particular. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/8XBVXQ/ HS 120 Maren Westermann PUBLISH F399CM@@pretalx.com -F399CM Emergent structures in noisy channel message-passing en en 20220831T135500 20220831T141000 001500

Emergent structures in noisy channel message-passing

Emergent structures in noisy channel message-passing is a blog post I wrote explaining a few experiments I did with neural network image generation. The idea is that we want to generate images that are robust under some noise. So we generate images from random representations. We perturb them and we try to decode the initial representation. This leads to the generator learning to create images with 2D structures. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/F399CM/ HS 120 Iliya Zhechev PUBLISH AFXCXH@@pretalx.com -AFXCXH Discrete event simulations of 'all electric' mines en en 20220831T141500 20220831T143000 001500

Discrete event simulations of 'all electric' mines

A typical 200 tonne payload mining truck can burn through more than 3000 liters of diesel fuel per day. Mining companies around the globe are searching for pathways to reduce their environmental impact, and clearly, reducing their dependence on diesel fuel is be a step in the right direction. Trials using diesel/electric hybrid, batteries, hydrogen and other energy sources are currently underway to serve as an alternative energy source to power these vehicles. The technology required for powering this class of large haulage vehicle is still in development, leaving mining companies unsure about the path they should take. Using the Python Simpy and NetworkX libraries to serve as the core, a discrete event simulation of real mining environments is created. Electric haulage trucks, electric trolley lines and more are modeled, and provide results aimed to help mining companies move to a more sustainable operation. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/AFXCXH/ HS 120 Nicholas Hall PUBLISH P7FQ3Y@@pretalx.com -P7FQ3Y Deep learning at the Radiology & Nuclear Medicine Clinic / University Hospital Basel en en 20220831T143500 20220831T145000 001500

Deep learning at the Radiology & Nuclear Medicine Clinic / University Hospital Basel

We will present how python and deep learning is used at the radiology department at the University Hospital Basel. The talk should give an overview of how the use cases are initially designed, developed and brought to production. One use case will be how deep learning helped quantifying the severity of COVID-19 infected lungs. Another use case will be how it can help to detect vertebrae fractures. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/P7FQ3Y/ HS 120 Joshy Cyriac Jakob Wasserthal PUBLISH JS97H9@@pretalx.com -JS97H9 How to make the most precise measurement en en 20220831T145500 20220831T151000 001500

How to make the most precise measurement

Structures on computer chips are getting smaller and smaller. To be able to print these nanometer-sized structures correctly, the surfaces of the used lithography optics have to be manufactured to sub-nanometer precision. We have now reached technical limits on how exactly one can measure these. This talk explains how we can get beyond that. Measurement precision and accuracy is all about separting the desired signal from any background. When all technical and signal processing techniques are exhausted, the only chance left is to know your background exactly. If you know everything about your measurement machine, you can calculate your background and thus separate signal from backgound. This talk describes how we at Carl Zeiss build complex simulations of our high-end measurement machines to enable the next generations of computer chips. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/JS97H9/ HS 120 Markus Gruber PUBLISH X8DUTF@@pretalx.com -X8DUTF Decision making under uncertainty en en 20220831T110500 20220831T113500 003000

Decision making under uncertainty

Mathematical optimization is widely used to solve challenging decision problem. Stochastic programming is a subfield of mathematical optimimization that involves uncertainty. In a stochastic programm some or all problem parameter are uncertain but follow a known probability distribution, whereas in determinstic optimization all problem parameters are assumed to be known exactly. The goal in stochastic programming is to find a policy that is feasible for all possible data instances and maximizes the expectation of some function of the decisions and the random variables. Because many real-world decisions involve uncertainty, stochastic programming has found applications in a broad range of areas ranging from finance to transportation to energy optimization. The Python library Pyomo is a great tool to solve mathematical optimization problems as it supports a wide range of problem types in mathematical optimization. In this talk we will see how to use Pyomo to build and solve decision models when data is assumed to be known exactly. We see different ways to include incertainty in an optimization model and how this can be implemented using the Pyomo. Moreover we see how we can combine data driven forecasts with optimal decision making. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/X8DUTF/ HS 118 Christian Barz PUBLISH UNTLSR@@pretalx.com -UNTLSR conda-forge: supporting the growth of the volunteer-driven, community-based packaging project en en 20220831T114000 20220831T121000 003000

conda-forge: supporting the growth of the volunteer-driven, community-based packaging project

The conda-forge project offers binary packages for Linux, macOS and Windows. It has greatly simplified software distribution for millions of users. As a volunteer-run Open Source project with build instructions for a plethora of software packages that are most often used in the multidisciplinary community of scientific computing, conda-forge has seen an unprecedented growth, not the least because of the success of Python in that field. In this talk we’ll take a look at the past, present and future of the project and showcase a number of projects in the overarching conda ecosystem that help with scaling conda-forge. The talk will go into detail how the conda-forge project is maintained by volunteers and where collaboration between participating organizations is a key aspect of shaping its future. We will also answer the question “Why not just use PyPI and the Python packaging stack?” and show how easy it is to create and submit packages to conda-forge. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/UNTLSR/ HS 118 Wolf Vollprecht Jannis Leidel Jaime Rodríguez-Guerra PUBLISH TXX8MQ@@pretalx.com -TXX8MQ conda-forge, mamba, boa and quetz - the evolution of package management for data science and beyond en en 20220831T133500 20220831T135000 001500

conda-forge, mamba, boa and quetz - the evolution of package management for data science and beyond

Mamba is widely used in the conda-forge community, a binary distribution of scienitific open-source packages for Windows, macOS and Linux. Today, mamba powers hundreds of automated builds for Python, C, C++ and many other programming languages every day. In this talk we will go into some of the details that make the conda-forge project and the mamba integration so successful. Furthermore, we will highlight some interesting new innovations coming to the mamba project. Thanks to a CZI grant we currently work on the sandboxing of environments on Linux and macOS, zchunk support for repodata, package metadata signing, OCI and S3 support and more. Additionally, we will take a look at a new build tool called boa. Boa comes with a new recipe format that is cleaner and faster to evaluate and makes building new packages a smooth process. It comes with an interactive mode to make packages easily debuggable. We will show how we have used boa to produce an experimental WASM distribution called "emscripten-forge" that builds WebAssembly enabled conda-packages that can readily be used in the web-browser with JupyterLite. Lastly, we will show recent improvements in quetz, the open-source conda package server. It is fully extensible, both in the front- and backend – something we want to use with the conda-forge project to add more features for users and package maintainers such as fast (metadata) package search. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/TXX8MQ/ HS 118 Wolf Vollprecht PUBLISH QRAUXL@@pretalx.com -QRAUXL Array expressions and symbolic gradients in SymPy en en 20220831T135500 20220831T141000 001500

Array expressions and symbolic gradients in SymPy

SymPy supports various ways to represent multidimensional mathematical expressions. For example, the matrix product M N where both M and N are matrix symbols, may be represented as: - `M*N` ==> matrix expression - `ArrayContraction(ArrayTensorProduct(M, N), (1, 2))` ==> array expression equivalent to matrix multiplication - `Sum(M[i, j]*N[j, k], (j, ...))` ==> index-explicit expression with summation equivalent to matrix multiplication Conversion from the array expression form is implemented in SymPy. Conversions generally work, except for some higher-dimensional array expression forms that cannot be converted to matrix expressions. The derivative of an array expressions by another array symbol returns an array expression. In the index-explicit form it is performed by using Kronecker delta, while the matrix form currently relies on the conversions to the array form. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/QRAUXL/ HS 118 Francesco Bonazzi PUBLISH XM3Q9S@@pretalx.com -XM3Q9S Memory maps to accelerate machine learning training en en 20220831T141500 20220831T143000 001500

Memory maps to accelerate machine learning training

When working on a machine learning project, one of the most time-consuming parts is the model's training. But a big part of the model's training is usually filled with filesystem I/O, which is very slow, especially in the context of computer vision. In this talk, we will focus on using memory maps for storing the datasets during training - which allows you to significantly reduce the training time of your model. We will also compare using memory maps to other ways to store the dataset during training, such as: in-memory datasets, one image per file, hdf5 file, etc. and will describe the strong and weak sides of the different approaches. Colab notebooks will be provided, and practical examples on significant performance improvements of popular online tutorials will be shown. We will also show how to address common shortcomings and painpoints of using memory maps in machine learning projects. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/XM3Q9S/ HS 118 Hristo Vrigazov PUBLISH QG8WUR@@pretalx.com -QG8WUR Optimizing inference for state of the art python models en en 20220831T143500 20220831T145000 001500

Optimizing inference for state of the art python models

Machine learning models are often created with an emphasis on how they run during training but with little regard for how they’ll perform in production. In this talk, you’ll learn what those issues are and how to address them using some state of the art models as an example. We’ll introduce the open source project, MLServer, and look at how features, such as multi-model serving and adaptive batching, can optimize performance for your models. Finally, you’ll learn how using an inference server locally can speed up the time to deployment when moving to production. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/QG8WUR/ HS 118 Ed Shee PUBLISH 89WNRG@@pretalx.com -89WNRG Industrial Strength DALLE-E: Scaling Complex Large Text & Image Models en en 20220831T145500 20220831T151000 001500

Industrial Strength DALLE-E: Scaling Complex Large Text & Image Models

Identifying the right tools to enable for high performance machine learning may be overwhelming as the ecosystem continues to grow at break-neck speed. This becomes particularly emphasised when dealing with the ever growingly popular large language and image generation models such as GPT2, OTP and DALL-E, between others. In this session we will dive into a practical showcase where we will be productionising the large image generation model DALL-E, and showcase some optimizations that can be introduced as well as considerations as the use-cases scale. By the end of this session practitioners will be able to run their own DALL-E powered applications as well as integrate these with functionalities from other large language models like GPT2, etc. We will be leveraging key tools in the Python ecosystem to achieve this, including Pytorch, HuggingFace, FastAPI and MLServer. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/89WNRG/ HS 118 Alejandro Saucedo PUBLISH JBPYFQ@@pretalx.com -JBPYFQ Education - Materials, methods, tools en en 20220831T110500 20220831T115000 004500

Education - Materials, methods, tools

This session focuses on issues related to education in the ecosystem, from three different aspects, and during the session, we focus on recent advances and existing and upcoming challenges. * Materials: how are projects dealing with documentation and education materials * Methods: What should we do to make our materials more accessible to underrepresented and/or historically marginalised groups? * Tools: What are the existing tools in the ecosystem helping us achieve the above goals, and what do we need to develop? We will give an overview of these different aspects. PUBLIC CONFIRMED Maintainer track https://pretalx.com/euroscipy-2022/talk/JBPYFQ/ HS 119 Mx Chiin-Rui Tan PUBLISH 99R3C7@@pretalx.com -99R3C7 [Maintainers track] Interoperability in the DataFrame landscape: DataFrame API & PyArrow Update en en 20220831T133500 20220831T142000 004500

[Maintainers track] Interoperability in the DataFrame landscape: DataFrame API & PyArrow Update

In this session, we want to share some updates on the DataFrame ecosystem: the DataFrame interchange protocol (https://data-apis.org/dataframe-protocol/latest/purpose_and_scope.html) and Arrow C Data interface (https://arrow.apache.org/docs/format/CDataInterface.html), and the integration of those interoperability protocols with different libraries. Further, we want to have an open conversation about challenges and requirements related to DataFrame interoperability and supporting multiple DataFrame libraries in projects. PUBLIC CONFIRMED Maintainer track https://pretalx.com/euroscipy-2022/talk/99R3C7/ HS 119 Joris Van den Bossche PUBLISH QHUSYT@@pretalx.com -QHUSYT [Maintainers track] Python in the browser en en 20220831T143500 20220831T152000 004500

[Maintainers track] Python in the browser

Recently it became possible to run Python and the scientific Python packages in the browser thanks to WebAssembly and [Emscripten](https://emscripten.org/). This is done in particular in the [Pyodide](https://github.com/pyodide/pyodide) and [emscripten-forge](https://github.com/emscripten-forge/recipes) projects. It allows for a scientific Python application, or a compute environment such as [JupyterLite](https://github.com/jupyterlite/jupyterlite), to be seamlessly accessible to a large number of users with very little effort or infrastructure requirements. At the same time, the scientific Python ecosystem did not evolve with the web in mind. We will discuss some of the challenges package maintainers may face when trying to run their package in the browser, and what could be done to overcome these. PUBLIC CONFIRMED Maintainer track https://pretalx.com/euroscipy-2022/talk/QHUSYT/ HS 119 Roman Yurchak Thorsten Beier PUBLISH HZYDMX@@pretalx.com -HZYDMX Supercharging Open Data with Open Privacy en en 20220901T090000 20220901T100000 010000

Supercharging Open Data with Open Privacy

Privacy is becoming an increasingly pressing topic in data collection and data science. Thankfully, Privacy Enhancing Technologies (or PETs) are maturing alongside the growing demand and concern. In this keynote, we’ll explore what possibilities emerge when using Privacy Enhancing Technology like differential privacy, encrypted computation and federated learning and investigate how these technologies could change the face of data science today. PUBLIC CONFIRMED Keynote https://pretalx.com/euroscipy-2022/talk/HZYDMX/ Aula Katharine Jarmul PUBLISH VFU9JL@@pretalx.com -VFU9JL Lessions learned from 10 years of Python in industrial reseach and development en en 20220901T103000 20220901T110000 003000

Lessions learned from 10 years of Python in industrial reseach and development

At the semiconductor division of Carl Zeiss it's our mission is to continuously make computer chips faster and more energy efficient. To do so, we go to the very limits of what is possible, both physically and technologically. This is only possible through massive research and development efforts. In this talk, we tell the story of how Python became a central part in our R&D activities. We explain what worked and what didn't. This leads to a conceptual understanding of how one should regard software in R&D contexts and what is different from classical production software. Based on this we understand how we should structure our software and how we need to set up our organization to support this. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/VFU9JL/ HS 120 Tim Hoffmann PUBLISH EFJC8C@@pretalx.com -EFJC8C Open Source Mission Support System for research aircraft missions en en 20220901T110500 20220901T112000 001500

Open Source Mission Support System for research aircraft missions

Examining the atmosphere by research aircraft is a costly and highly collaborative effort involving a large community of scientists, their one-of-a-kind measurement instruments and a very limited amount of available flight-hours. The MSS Software (mss.rtfd.io) is used for planning research aircraft missions. Such missions involve the measurement of interesting atmospheric situation by research aircraft. These missions typically involve a wide range of one-of-a-kind instruments designed and operated by different scientific institution, with different requirements and operational conditions. The software project contains several components. Scripts for automated download and process of weather forecast data for the server components. This model forecast data is needed to guide the aircraft to the location of interest. The data is visualized by an extended OGC webmap server capable of visualising the big data generated by complex 3-D atmospheric simulations in a highly configurable manner and delivering the resulting small PNG images over the internet. Another server based on socketIO enables collaborative working from different locations on the same flightpath simultaniously. The flightpath editor is a QT UI that allows to overlay the pictures produced by our server. The flightpath can be changed accordingly vertically and horizontally. We provide also a view based on the simulated data to visualize data similar to an insitu measurement along the flightpath. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/EFJC8C/ HS 120 Reimar Bauer PUBLISH LYBCHK@@pretalx.com -LYBCHK Data-Driven Thresholding for Extreme Event Detection in Geosciences en en 20220901T112500 20220901T114000 001500

Data-Driven Thresholding for Extreme Event Detection in Geosciences

Extreme weather events are a well known source of human suffering, loss of life, and financial hardship. Amongst these, tropical cyclones are notoriously impactful, leading to significant interest in predicting the genesis, tracks, and intensity of these storms - a task which continues to present significant challenges. In particular, tropical cyclogenesis (TCG) can be described as “a needle in a haystack” problem, and steps must be taken to make predictions tractable. Previously, the filtering of non-genesis points by thresholding predictive variables has been described, with thresholds being selected to reduce the number of discarded TCG cases. In the art, this thresholding has often been carried out empirically, that while effective relies on domain knowledge. This talk instead proposes the development of a systematic, machine-learning-based approach implemented in Python. The method is designed to be interpretable to the point of becoming transparent machine learning. Threshold values that minimize the false-alarm rate and maintain a high recall are found, and then combined in a forward selection algorithm. As other extreme events in the geosciences are considered needle in the haystack problems, the described approach can be of use in reducing the variable space in which to study and predict the events. Finally, the transparent nature of the proposed approach can provide simple insight into the conditions in which these events occur. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/LYBCHK/ HS 120 Milton Gomez PUBLISH 9VCPM3@@pretalx.com -9VCPM3 Real-time estimation of an heat pump I/O state with IoT data. en en 20220901T114500 20220901T121500 003000

Real-time estimation of an heat pump I/O state with IoT data.

In the present time, we are facing a continuous growing of the energy price. It is then important to optimize the use of heat pumps, both in domestic and industrial environments. Using an opportunely labeled dataset of accelerometer, speed or relative position over time coming from a cheap sensor it is possible to estimate the I/O state of any heating or cooling engine. This new real-time measure allows then to compute the energy consumption and to study the most cheap usage scheme. In this presentation we will show a real-case implementation of some fast binary classifiers, from basic statistics to machine learning, assessing the performance of each method in terms of computational time, precision and accuracy levels. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/9VCPM3/ HS 120 Davide Poggiali PUBLISH 9GUNEZ@@pretalx.com -9GUNEZ A Primer to Maintainable Code en en 20220901T131500 20220901T134500 003000

A Primer to Maintainable Code

In this talk I will provide an overview of best practices for software quality. Practices and libraries to look deeper into included, hypes to be ignored providing simple guidelines to follow for writing code your peers will love. Jupyter notebooks are often messy, scripted applications like to contain redundant code and like to fail just before the result - wasting precious time. The code works for one-time use, but is difficult to maintain, reuse, or read by colleagues. In this talk I will present best practices to make code: - more readable - better to maintain - re-usable Flag potentially bad practices as: - closures - using too many third libraries Practices how to best design applications including: - refactoring - versioning - DRY - when to write tests - documentation Provide an overview of the habitats production-ready code likes to live in like CI/CD pipelines. After the talk the audience will have a guideline on how to develop better code, and be aware of potential blind spots. Software quality is important - especially for research! This talk provides an overview of best practices and libraries to dive deeper into, hypes to ignore, and simple guidelines to follow to write code that your peers will love. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/9GUNEZ/ HS 120 Alexander CS Hendorf PUBLISH B3AGKG@@pretalx.com -B3AGKG scikit-learn and fairness, tools and challenges en en 20220901T135000 20220901T142000 003000

scikit-learn and fairness, tools and challenges

On the machine learning side, scikit-learn has been one of the most commonly used libraries which has been extended by third party libraries such as imbalanced-learn and scikit-lego. However, when it comes to incorporating fairness constraints in a usual scikit-learn pipeline, there are challenges and limitations related to the API, which has made developing a scikit-learn compatible fairness focused package challenging and hampering the adoption of these tools in the industry. In this talk, we start with a common classification pipeline, then we assess fairness/bias of the data/outputs using disparate impact ratio as an example metric, and finally mitigate the unfair outputs and search for hyperparameters which give the best accuracy while satisfying fairness constraints. This workflow will expose the limitations of the API related to passing around feature names and/or sample metadata in a pipeline down to the scorers. We discuss certain workarounds and then talk about the work being done to address these issues and show how the final solution would look like. After this talk, you will be able to follow the related discussions happening in these open source communities and know where to look for them. The code and the presentation will be publicly available on github. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/B3AGKG/ HS 120 Adrin Jalali PUBLISH BYCNN7@@pretalx.com -BYCNN7 Scaling scikit-learn: introducing new computational foundations en en 20220901T145000 20220901T152000 003000

Scaling scikit-learn: introducing new computational foundations

scikit-learn is an open-source scientific library for machine learning in Python. Since its first release in 2010, the library gained a lot of traction in education, research and the wider society, and has set several standards for API designs in ML software. Nowadays scikit-learn is of one the most used scientific library in the world for data analysis. It provides reference implementations of many methods and algorithms to a userbase of millions. With the renewed interest in machine-learning based methods in the last years, other libraries providing efficient and highly optimised methods (such as for instance LightGBM and XGBoost for Gradient-Boosting-based methods) have emerged. Those libraries have encountered a similar success, and have put performance and computational efficiency as top priorities. In this talk, we will present the recent work carried over by the scikit-learn core-developers team to improve its native performance. This talk will cover elements of the PyData ecosystem and the CPython interpreter with an emphasis on their impact on performance. Computationally expensive patterns will then be covered before presenting the technical choices associated with the new foundational implementations, keeping the project requirements in mind. At the end, we will take a quick look at the future work and collaborations on hardware-specialised computational kernels. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/BYCNN7/ HS 120 Julien Jerphanion PUBLISH B9N3U9@@pretalx.com -B9N3U9 Continuous and on demand benchmarking en en 20220901T152500 20220901T154000 001500

Continuous and on demand benchmarking

In this talk, we will discuss how we can use ASV (airspeed velocity) and on demand cloud providers to mimic the usual setup of dedicated servers to run benchmarking tests. Currently, a lot of projects use dedicated servers to run their benchmarking suite, which usually is not economical as the majority of the time the hardware is unused. We can get rid of the setup of dedicated hardware + ongoing costs associated with it by only using resources when required. Outline 5 mins: - Why benchmarking? - The usual ways of running the benchmarking suite on dedicated hardware. - Using GitHub Actions reliably for "relative benchmark" testing (A quick shout out to the blog post by Quansight)  10 mins: - How we can use container technology to setup our tests and run them on demand on "dedicated" hardware to cut down on costs and give a lower barrier to entry to set up a benchmarking suite for projects. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/B9N3U9/ HS 120 Mridul Seth PUBLISH HPTWUT@@pretalx.com -HPTWUT Sliding into Causal Inference, with Python! en en 20220901T103000 20220901T110000 003000

Sliding into Causal Inference, with Python!

The talk is aimed at data practitioners, preferably with basic knowledge of Python and statistics. That said, the focus of the talk is to nurture an intuitive understanding of the subject first, and implementation second. By the end of the talk I hope audience members could identify causal inference problems, have an intuitive understanding of the different tools they can apply to these problems, and have the appetite to further their learning! The talk will cover the problem of answering causal questions (The Fundamental Problem of Causal Inference) and the main tools to address it. The emphasis will be on intuitive understanding how the different tools work, rather than pesky underlying assumptions, complex notation or convoluted literature. Just enough theory and lines of code to get the message across. Outline: - *Introduction to parallel universes and "what if?" questions?* [2 mins] - *The golden standard for causal inference.* We'll discuss randomised controlled experiments and also set the scene for cases these aren't possible. [6 mins] Three key tools: - *Differences-in-Differences* [3 mins] - *Propensity score methods* [4 mins] - *Synthetic Controls* (or: creating an alternate universe on your machine) [5 mins] What's next: [5 mins] A wrap up that includes: - *What we didn't cover* (a few words about other techniques, DAGs, etc.) - *Quick overview of Python tools for causal inference* - *Where do we go from here* - resources, curriculums, readings and communities. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/HPTWUT/ HS 118 Alon Nir PUBLISH BEHTMU@@pretalx.com -BEHTMU Machine learning with missing values en en 20220901T110500 20220901T112000 001500

Machine learning with missing values

In many data-science applications, the data may come with missing values. There is a rich statistical literature on performing analysis with missing values. However, machine learning brings new tradeoffs: how to deal with missing-values at test time? Should we really care about recovering the model suitable for fully-observed data? I will cover both the classic theory and recent theoretical advances. I will show how scikit-learn can be used to implement various solutions, and how these illustrate the theory. Tentative outline: - The classic statistical view on missing values - Missing at Random Settings: why it is important - Imputation, and corresponding scikit-learn tools - Prediction for missing values - Simple predictors need very good predictors - Rich predictors work with simple imputers, even outside Missing at Random settings PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/BEHTMU/ HS 118 Gaël Varoquaux PUBLISH EXQHBU@@pretalx.com -EXQHBU Discovering Mathematical Optimization with Python en en 20220901T112500 20220901T114000 001500

Discovering Mathematical Optimization with Python

Mathematical optimization is an important tool in decision-making. With it, it is possible to optimize the economic benefit, time, distance, or any desired variable. The first step in optimization is the construction of a model. A good choice of model is essential. If the model is too simple, it will not provide useful information about the problem. If it is too complex, it may be too difficult to solve. After the model has been created, it is possible to solve the problem, usually with the help of a computer. It is important to note that there is no universal optimization algorithm; rather, there are different algorithms that are adapted to different optimization problems. The correct choice of the right algorithm for a specific application usually rests with the user. This choice is important, as it can determine whether the problem is solved quickly or slowly and, indeed, whether the solution is found. In this talk we will learn how to solve mathematical optimization problems, using Python and different optimization libraries. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/EXQHBU/ HS 118 Pamela Alejandra Bustamante Faúndez PUBLISH 8RAJX7@@pretalx.com -8RAJX7 Increase citations, ease review & collaboration – Making machine learning in research reproducible en en 20220901T114500 20220901T121500 003000

Increase citations, ease review & collaboration – Making machine learning in research reproducible

One of the tenets of science is to be reproducible. But if we always did what we’re supposed to, the world would be a better and easier place. However, there are benefits to making science reproducible that directly benefit researchers, especially in computational science and machine learning. These benefits are like the title says: - Easier review cycles - More citations - More collaboration But it goes further. Reproducibility is a marketable skill outside of academia. When we work in companies that apply data science or machine learning, these companies know that technical debt can slowly degrade a code base and in some cases like Amazon and Google, the machine learning system has to be so reproducible that we expect the entire training and deployment to work automatically on a press of a button. Technical debt is also a problem in academia, but here it is more framed in the devastating prospect of the only postdoc leaving that knows how to operate the code base. Luckily, we have a lot of work cut out for us already! These benefits, and a few others, like making iteration, and therefore frequent publication easier, do not come at a proportional cost. Most of the methods to increase code quality in machine learning projects of applied scientists are in fact fairly easy to set up and run! So how do we actually go about obtaining these goals? ## Model Evaluation Applying machine learning in an applied science context is often method work. We build a prototype model and expect want to show that this method can be applied to our specific problem. This means that we have to guarantee that the insights we glean from this application generalize to new data from the same problem set. This is why we usually import `train_test_split()` from scikit-learn to get a validation set and a test set. But in my experience, in real-world applications, this isn’t always enough. In science, we usually deal with data that has some kind of correlation in some kind of dimension. Sometimes we have geospatial data and have to account for Tobler’s Law, i.e. things that are closer to each other matter more to each other than those data points at a larger distance. Sometimes we have temporal correlations, dealing with time series, where data points closer in time may influence each other. Not taking care of proper validation, will often lead to additional review cycles in a paper submission. It might lead to a rejection of the manuscript which is bad enough. In the worst case scenario, our research might report incorrect conclusions and have to be retracted. No one wants rejections or even retractions. So we’ll go into some methods to properly evaluate machine learning models even when our data is not “independent and identically distributed”. ## Benchmarking Another common reason for rejections of machine learning papers in applied science is the lack of proper benchmarks. This section will be fairly short, as it differs from discipline to discipline. However, any time we apply a superfancy deep neural network, we need to supply a benchmark to compare the relative performance of our model to. These models should be established methods in the field and simpler machine learning methods like a linear model, support-vector machine or a random forest. ## Model Sharing Some journals will require the sharing of code or models, but even if they don’t we might benefit from it. Anytime we share a model, we give other researchers the opportunity to replicate our studies and iterate upon them. Altruistically, this advances science, which in and of itself is a noble pursuit. However, this also increases the citations of our original research, a core metric for most researchers in academia. In this section, we explore how we can export models and make our training codes reproducible. Saving a model from scikit-learn is easy enough. But what tools can we use to easily make our training code adaptable for others to import and try out that model? Specifically, I want to talk about: - Automatic Linters - Automatic Formatting - Automatic Docstrings and Documentation - Docker and containerization for ultimate reproducibility ## Testing Machine learning is very hard to test. Due to the nature of the our models, we often have soft failures in the model that are difficult to test against. Writing software tests in science, is already incredibly hard, so in this section we’ll touch on - some fairly simple tests we can implement to ensure consistency of our input data - avoid bad bugs in data loading procedures - some strategies to probe our models ## Interpretability One way to probe the models we build is to test them against the established knowledge of domain experts. In this final section, we’ll explore how to build intuitions about our machine learning model and avoid pitfalls like spurious correlations. These methods for model interpretability increase our trust into models, but they can also serve as an additional level of reproducibility in our research and a valuable research artefact that can be discussed in a publication. This part of the tutorial will also go into some considerations why the feature importance of tree-based methods can serve as a start but often shouldn’t be used as the sole source of truth regarding feature interpretation of our applied research. This section will introduce tools like `shap`, discuss feature importance, and manual inspection of models. ## Ablation Studies Finally, the gold standard in building complex machine learning models is proving that each constituent part of the model contributes something to the proposed solution. Ablation studies serve to dissect machine learning models and evaluate their impact. In this section, we’ll finally discuss how to present complex machine learning models in publications and ensure the viability of each part we engineered to solve our particular problem set. ## Conclusion Overall, this tutorial is aimed at applied scientists that want to explore machine learning solutions for their problems. This tutorial focuses on a collection of “easy wins” that scientists can implement in their research to avoid catastrophic failures and increase reproducibility with all its benefits. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/8RAJX7/ HS 118 Jesper Dramsch PUBLISH XAGVJZ@@pretalx.com -XAGVJZ Scientific Python in the browser with Pyodide en en 20220901T131500 20220901T134500 003000

Scientific Python in the browser with Pyodide

Python can run in diverse environments, including most recently in the browser. In this talk, we will look at the growing Python in the browser ecosystem, with a focus on the Pyodide project. We will discuss the remaining challenges as well as new possibilities it offers for scientific computing, education, and research. Pyodide is a Python distribution for the browser and Node.js. It includes a build of CPython 3.9 for WebAssembly/Emscripten, a number of common Python packages (including the core scientific stack) as well as the ability to install pure Python packages from PyPI. Pyodide comes with a robust Javascript ⟺ Python foreign function interface so that you can mix these two languages in your code with minimal friction. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/XAGVJZ/ HS 118 Roman Yurchak PUBLISH SYA7GA@@pretalx.com -SYA7GA Interactive Data Science in the browser with JupyterLite and Emscripten Forge en en 20220901T135000 20220901T142000 003000

Interactive Data Science in the browser with JupyterLite and Emscripten Forge

This will be a functional talk to present JupyterLite with concrete examples and live demos in the web browser. The structure of the presentation is as follows: - Introduction - Easy interactive computing in the browser - A lightweight Jupyter Frontend running in the browser - Boots in seconds - Deployment and scalability made easy - Demos of the Features: - the WebAssembly powered Python kernel - Support for existing JupyterLab Extensions, IPython, Jupyter Widgets, interactive visualizations - Support for Real Time Collaboration - Working with files and notebooks - A quick overview of the underlying architecture - Plugin-based as a Lumino application - Extensible by design: most JupyterLab extensions are compatible by default and new kernels can easily be added - Emscripten Forge - Presentation of the distribution that enables the emscripten platform for the mamba (conda) package manager - Allows freezing in time a given WebAssembly environment. This will enable a new level of computational reproducibility. - Based on the WebAssembly standard supported by all web browsers - Demo of using a custom set of Python packages in a JupyterLite deployment - A wide range of use cases - Embed a live Python console on your website 🚀 - Powering the numpy and sympy documentation to let anyone try the libraries in the browser without installing anything - Education: easy access to computing environment without the trouble of installing anything - Reducing the load on public services like mybinder.org - What's coming up next PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/SYA7GA/ HS 118 Jeremy TULOUP, QuantStack Martin Renou Thorsten Beier PUBLISH 9LMAXM@@pretalx.com -9LMAXM Revolutionalise Data Visulization with PyScript en en 20220901T145000 20220901T152000 003000

Revolutionalise Data Visulization with PyScript

At the beginning of this talk, we will go over what PyScript is and how to use it: no need to install it, just put a CDN URL in an HTML file. This part will cover some basic knowledge about it, why is it unique and why it can revolutionize data visualisation, for those who have not heard much about PyScript. After that, we will go over 3 examples: one interactive data plot, one interactive map visualization and one integration with D3. Besides showing the result, we will also have a deeper look at the code, the key to making similar visualization so you can learn a few tricks to make your own PyScript data visualization as well. This talk is for anyone who needs a simple and no fuzz way to present data findings and visualization. As PyScript runs only on the browser, it will be an optimal way to share data findings through visualization. PUBLIC CONFIRMED Talk (long) https://pretalx.com/euroscipy-2022/talk/9LMAXM/ HS 118 Cheuk Ting Ho PUBLISH 9VKWZP@@pretalx.com -9VKWZP Pragmatic Panel: Build and Deploy Complex Data-Driven WebApps en en 20220901T152500 20220901T154000 001500

Pragmatic Panel: Build and Deploy Complex Data-Driven WebApps

Panel is a mature tool for quickly creating custom, interactive web apps and dashboards by connecting user-defined widgets to plots, images, tables, or text. Panel allows scientists to create their own apps for data exploration quickly and easily without requiring them to know javascript or work with an external developer team. It provides the framework for building much more complex dashboards which look and feel like a mature web app. By allowing prototyping inside Jupyter and deployment outside Jupyter, it bridges the gap between exploration and production. In this talk, we discuss the practical aspects of complex data-driven dashboards. There are tutorials and guides available which help teach new users the basics, but this talk focuses on the challenges of building and sharing more complex, industry-ready, applications. There are a variety of issues which arise when you build fully featured applications, and we will share the solutions we have developed. We will demonstrate these solutions as we walk through the entire lifecycle from data, though exploratory analysis to deployment as a finished website. Examples of the topics we will cover include: best practices; creating multi-page apps where you may not know the number of pages ahead of time; Debugging cascading effects of user interactions; Deployment in air-gapped environments; using templates and customizing Panel’s look and feel. These lessons were distilled from Panel apps we created for clients in finance, manufacturing and science. The datasets and code for these examples in the talk will be made available via a github repository. PUBLIC CONFIRMED Talk https://pretalx.com/euroscipy-2022/talk/9VKWZP/ HS 118 Pierre-Olivier Simonard PUBLISH K8DEQK@@pretalx.com -K8DEQK [Maintainer Track] Scientific Python / SPECs en en 20220901T103000 20220901T111500 004500

[Maintainer Track] Scientific Python / SPECs

The Scientific Python project aims to better coordinate the ecosystem and grow the community. This session focuses on our efforts to better coordinate project development, and to improve shared infrastructure. In this session together we will discuss project goals and recent technical work. The Scientific Python project’s vision is to help pave the way towards a unified, expanded scientific Python community. It focuses its efforts along two primary axes: (i) to create a joint community around all scientific projects and (ii) to support maintainers by building cross-cutting technical infrastructure and tools. In this session we mostly focus on the second aspect. The project has already launched a process whereby projects can, voluntarily, adopt reference guidelines; these are known as SPECs or Scientific Python Ecosystem Coordination documents. SPECs are similar to projects specific guidelines like PEPs, NEPs, SLEPs, and SKIPs, to name a few. The distinction being that SPECs have a broader scope, targeted at all (or most) projects from the scientific Python ecosystem. The project also provides and maintains tools to help maintainers. This includes a theme for the project websites (currently used on, e.g., numpy.org and scipy.org), a self-hosted privacy-friendly web analytics platform, a community discussions forum, a technical blog, and project development statistics. We present all these tools, discuss various upcoming SPECs, and highlight the project’s future potential. The Scientific Python project is already supported by eight core projects: IPython, Matplotlib, NetworkX, NumPy, pandas, scikit-image, scikit-learn, and SciPy. The organization has spent the last several months working on the infrastructure, and is now ready to engage more widely to help grow and support the community. PUBLIC CONFIRMED Maintainer track https://pretalx.com/euroscipy-2022/talk/K8DEQK/ HS 119 Jarrod Millman PUBLISH PA7NUF@@pretalx.com -PA7NUF [Maintainers Track] Contributor Experience & Diversity en en 20220901T112500 20220901T121000 004500

[Maintainers Track] Contributor Experience & Diversity

Most of us have been hearing about Diversity Equity and Inclusion (DEI) for some years now, and even had access to many resources by now. Our projects have codes of conduct, and some have been doing sprints and mentorships. But how much has fundamentally changed? Let’s meet for an honest conversation about the challenges of DEI actions, and culture change. How do we achieve long-term impact? What are low-hanging fruit? We can share hard-to-ask questions, effective tools, experiences that shaped our approach, and see if we can all nudge each other forward a little. Inclusion happens at the community level, also when we want to address DEI itself. So, we will need to create a safe space for hard questions and leave judgment at the door. Thanks to our CZI grant to advance an inclusive culture in the scientific Python ecosystem, we have created the contributor experience lead role. We have been working with NumPy, SciPy, Matplotlib, and pandas to learn how to integrate this new role to a project, and how to introduce contributor hospitality techniques. We are working on creating widely available resources, and we would benefit from hearing from maintainers from the wider community. PUBLIC CONFIRMED Maintainer track https://pretalx.com/euroscipy-2022/talk/PA7NUF/ HS 119 Noa Tamir