Patrick Altmeyer

Treating deep neural networks probabilistically comes with numerous advantages including improved robustness and greater interpretability. These factors are key to building artificial intelligence (AI) that is trustworthy. A drawback commonly associated with existing Bayesian methods is that they increase computational costs. Recent work has shown that Bayesian deep learning can be effortless through Laplace approximation. This talk presents an implementation in Julia: `BayesLaplace.jl`.

#### Problem: Bayes can be costly 😥

Deep learning models are typically heavily under-specified in the data, which makes them vulnerable to adversarial attacks and impedes interpretability. Bayesian deep learning promises an intuitive remedy: instead of relying on a single explanation for the data, we are interested in computing averages over many compelling explanations. Multiple approaches to Bayesian deep learning have been put forward in recent years including variational inference, deep ensembles and Monte Carlo dropout. Despite their usefulness these approaches involve additional computational costs compared to training just a single network. Recently, another promising approach has entered the limelight: Laplace approximation (LA).

#### Solution: Laplace Redux 🤩

While LA was first proposed in the 18th century, it has so far not attracted serious attention from the deep learning community largely because it involves a possibly large Hessian computation. The authors of this recent [NeurIPS paper](https://arxiv.org/abs/2106.14806) are on a mission to change the perception that LA has no use in DL: they demonstrate empirically that LA can be used to produce Bayesian model averages that are at least at par with existing approaches in terms of uncertainty quantification and out-of-distribution detection, while being significantly cheaper to compute. Our package [`BayesLaplace.jl`](https://github.com/pat-alt/BayesLaplace.jl) provides a light-weight implementation of this approach in Julia that allows users to recover Bayesian representations of deep neural networks in an efficient post-hoc manner.

#### Limitations and Goals 🚩

The package functionality is still limited to binary classification models trained in Flux. It also lacks any framework for optimizing with respect to the Bayesian prior. In future work we aim to extend the functionality. We would like to develop a library that is at least at par with an existing Python library: [Laplace](https://aleximmer.github.io/Laplace/). Contrary to the existing Python library, we would like to leverage Julia's support for language interoperability to also facilitate applications to deep neural networks trained in other programming languages like Python an R. 

#### Further reading 📚

For more information on this topic please feel free to check out my introductory blog post: [[TDS](https://towardsdatascience.com/go-deep-but-also-go-bayesian-ab25efa6f7b)], [[blog](https://www.paltmeyer.com/blog/posts/effortsless-bayesian-dl/)]. Presentation slides can be found [here](https://www.paltmeyer.com/LaplaceRedux.jl/dev/resources/juliacon22/presentation.html#/title-slide).

Large-Scale Machine Learning Inference with BanyanONNXRunTime.jl

Blue

Effortless Bayesian Deep Learning through Laplace Redux

This session hosts all of this year's experience talks.

In cosmology, the study of large-scale structure is related to the three-dimensional distribution of dark matter in the Universe. Dark matter has only gravitational interaction and can be easily simulated. However, what we observe are the galaxies. I translated from Python3 my code to populate dark matter simulation with galaxies in Julia. In a month, starting from no Julia experience, I obtained a speed up of about 10. Now I extensively use Julia in my work.

Populating cosmological simulations with galaxies using Julia

I wear a Samsung smartwatch, which has various sensors to record activities such as steps, distance, climbed floors and heart rate. The data recorded by these sensors can be downloaded in the form of CSV files. 

I was inspired to do a fun data science project, where I could explore various packages from the Julia ecosystem. I was easily able to create interactive visualizations, which provided a lot of insight on my daily health routines and how I could improve upon them.

Analyze Your Health and Fitness Data using Julia

Julia is a promising and powerful language for agent-based modeling and it already has a fully functional agent-based modeling framework called Agents.jl. This framework is clearly faster than the other popular frameworks in use today, and also offers unique features that are difficult to replicate. At the same time, there are points of design and documentation that could still be improved, especially when it comes to addressing beginners.

Agent-Based Modeling with Julia

La rapidez de Julia combinada con los notebooks reactivos de Pluto permiten ilustrar de forma interactiva la importancia de visualizar las pseudo-observaciones de la función cópula subyacente de un vector aleatorio, y cómo los scatterplots de los datos originales pueden resultar engañosos.

Visualizando dependencia probabilística con Pluto.jl

Pedestrian models are used by practitioners to construct safer, more comfortable, and more efficient pedestrian environments. They allow engineers to predict the impact of their design choices before costly decisions are made. To make accurate predictions the models must be calibrated. This talk covers the integration between DifferentialEquations.jl and Turing.jl and how we’ve been able to go beyond the state of the art in pedestrian model calibration by using them.

Calibrating Pedestrian Models with Turing.jl

I can give a Julia Experiences talk in Spanish or English, however I prefer to give it in Spanish. 
El problema abordado en esta plática es difundir distintos métodos de solución a un problema de precisión numérica. El ejercicio consiste en ajustar un polinomio de grado 10 propuesto a un conjunto de 82 pares ordenados. En Julia se desarrollaron cuatro métodos de solución distintos que incluyen teoría algebraica y uso de paquetes como GLM y Polynomials.

¿Cómo resolví un problema de precisión numérica de NIST en Julia

En la Fundación América Transparente, construimos plataformas código abierto que permiten acceder fácilmente a información de transparencia gubernamental, empoderando a tanto ciudadanos como periodistas a fiscalizar a sus gobiernos. 

Para esto, utilizamos Julia para manejar la recolección, limpieza, enriquecimiento e indexación de datos, permitiéndonos compilar información de cientos de entidades públicas.

Combatiendo la corrupción usando Julia

Reproducibility of data and analysis is still lacking in experimental physical chemistry. I share my experience making my PhD research reproducible using Julia after completing a months-long transition from Python. I highlight tools that should encourage experimental scientists to produce more easily shareable and readable analytic code.

Making reproducible research with Julia

Managing many environments which have many dependencies, and therefore compat entries, can be a bit tedious. CompatDevTools.jl is a very small and simple package, for developers and maintainers, to help assist maintaining synchronized compat entries across many environments.

CompatDevTools.jl: To ease managing many compat entries

Open science helps in creating reproducible resources in a transparent manner, which further improves inclusion and fairness in the process. In this talk I share the benefits of following open science principles in community building work that I learnt during my participation in the [Cohort-4 of the Open Life Science Programme (OLS-4)](https://openlifesci.org/ols-4/projects-participants/). These principles can be applied to research and community work in many domains.

Community Building using Open Science Principles

As a beginner in Julia, my experience aims to get people familiar with the Julia language. Sharing the reason I started Julia, my first steps and how Julia is becoming the language of my heart.

Starting my journey in Julia

Scientific publications come in many forms: Markdown, HTML, PDF, ePub and more. Wouldn't it be nice to have a tool that can produce all of these different output formats from the same input? With [Quarto](https://quarto.org/) scientific publishing always starts from the same place: a plain Markdown document blended with essentially any programming language of your choice and a YAML header defining your output. I would like to demonstrate its potential value for the Julia community.

Julia and Quarto: a Match Made in Heaven? 🌤

O AJA objetiva promover a inclusão social e ambiental de jovens maranhenses por meio do estímulo à participação em projetos socioambientais sustentáveis, visando contribuir com a preservação do meio ambiente além de ampliar as oportunidades de geração de renda e melhoria da qualidade de vida.

Programa Agente Jovem Ambiental - AJA

This talk provides an example of how we use Julia in the physics of nanomagnetism research. We model a system of nanomagnets on a particular size lattice and try to obtain various physical properties of such a system. The code is then adapted to run on an HPC cluster to get the desired physical parameters.

Why Julia is well suited for Condensed Matter Physics research

Purple

Julia Frank

Agustin Covarrubias

Valeria Perez

Saranjeet Kaur Bhogal

Marina Cagliari

Garrek Stemo

Jeremiah Lasquety-Reyes

Dr. Vikas Negi

Martin Smit

Fábio Rodrigues Sodré

Arturo Erdely

Olga Eleftherakou

Charlie Kawczynski

Juliacon Experiences

We propose [`CounterfactualExplanations.jl`](https://www.paltmeyer.com/CounterfactualExplanations.jl/dev/): a package for explaining black-box models through counterfactuals. Counterfactual explanations are based on the simple idea of strategically perturbing model inputs to change model predictions. Our package is novel, easy-to-use and extensible. It can be used to explain custom predictive models including those developed and trained in other programming languages.

### The Need for Explainability ⬛

Machine learning models like deep neural networks have become so complex, opaque and underspecified in the data that they are generally considered as black boxes. Nonetheless, they often form the basis for data-driven decision-making systems. This creates the following problem: human operators in charge of such systems have to rely on them blindly, while those individuals subject to them generally have no way of challenging an undesirable outcome:

> “You cannot appeal to (algorithms). They do not listen. Nor do they bend.”
> — Cathy O'Neil in *Weapons of Math Destruction*, 2016

### Enter: Counterfactual Explanations 🔮

Counterfactual Explanations can help human stakeholders make sense of the systems they develop, use or endure: they explain how inputs into a system need to change for it to produce different decisions. Explainability benefits internal as well as external quality assurance. Explanations that involve realistic and actionable changes can be used for the purpose of algorithmic recourse (AR): they offer human stakeholders a way to not only understand the system's behaviour, but also strategically react to it. Counterfactual Explanations have certain advantages over related tools for explainable artificial intelligence (XAI) like surrogate eplainers (LIME and SHAP). These include:

- Full fidelity to the black-box model, since no proxy is involved. 
- Connection to Probabilisitic Machine Learning and Causal Inference.
- No need for (reasonably) interpretable features.
- Less susceptible to adversarial attacks than LIME and SHAP.

### Problem: Limited Availability in Julia Ecosystem 😔

Software development in the space of XAI has largely focused on various global methods and surrogate explainers with implementations available for both Python and R. In the Julia space we have only been able to identify one package that falls into the broader scope of XAI, namely [`ShapML.jl`](https://github.com/nredell/ShapML.jl). Support for Counterfactual Explanations has so far not been implemented in Julia. 

### Solution: `CounterfactualExplanations.jl` 🎉

Through this project we aim to close that gap and thereby contribute to broader community efforts towards explainable AI. Highlights of our new package include:

- **Simple and intuitive interface** to generate counterfactual explanations for differentiable classification models trained in Julia, Python and R.
- **Detailed documentation** involving illustrative example datasets and various counterfactual generators for binary and multi-class prediction tasks.
- **Interoperability** with other popular programming languages as demonstrated through examples involving deep learning models trained in Python and R (see [here](https://www.paltmeyer.com/CounterfactualExplanations.jl/dev/tutorials/interop/)).
- **Seamless extensibility** through custom models and counterfactual generators (see [here](https://www.paltmeyer.com/CounterfactualExplanations.jl/dev/tutorials/models/)). 

### Ambitions for the Package 🎯

Our goal is to provide a go-to place for counterfactual explanations in Julia. To this end, the following is a non-exhaustive list of exciting future developments we envision:

1. Additional counterfactual generators and predictive models.
2. Additional datasets for testing, evaluation and benchmarking.
3. Improved preprocessing including native support for categorical features.
4. Support for regression models.

The package is designed to be extensible, which should facilitate contributions through the community.

### Further Resources 📚

For some additional colour you may find the following resources helpful:

- [Slides](https://www.paltmeyer.com/CounterfactualExplanations.jl/dev/resources/juliacon22/presentation.html#/title-slide).
- [Blog post](https://towardsdatascience.com/individual-recourse-for-black-box-models-5e9ed1e4b4cc) and [motivating example](https://www.paltmeyer.com/CounterfactualExplanations.jl/dev/cats_dogs/).
- Package docs: [[stable]](https://pat-alt.github.io/CounterfactualExplanations.jl/stable), [[dev]](https://pat-alt.github.io/CounterfactualExplanations.jl/dev).
- [GitHub repo](https://github.com/pat-alt/CounterfactualExplanations.jl).

Patrick Altmeyer

Talks:

Effortless Bayesian Deep Learning through Laplace Redux

Juliacon Experiences

Explaining Black-Box Models through Counterfactuals

Platinum sponsors

Gold sponsors

Silver sponsors

Media partners

Community partners

Fiscal Sponsor