Channel Title: The Julia Programming Language Channel Description: Julia is a high-performance, dynamic programming language for modern technical computing. It solves the two language problem by being simultaneously as fast as C and as easy as Python. The built-in package manager provides access to over 6,000 Julia packages created by the Julia community, in addition to foreign function interfaces for tens of thousands of C, Fortran, Python, and R libraries. The Julia package ecosystem includes best in class packages in a number of ecosystems: Image Processing, Machine Learning, Data Science, Optimization, Parallel computing, Cloud computing, Automatic Differentiation, Graph Processing, Probabilistic Programming, Finite Elements, Computational Biology, Ecology, Climate science, Astrophysics, Quantum Computing, and much more. <video> Visualization and analysis of 3D Lightning Mapping Array data | van der Velde | JuliaCon 2024 Description: Visualization and analysis of 3D Lightning Mapping Array data by Oscar van der Velde PreTalx: https://pretalx.com/juliacon2024/talk/79BGUS/ The 3D Lightning Mapping Array (LMA) is a regional network for the detection of lightning channels as they propagate through the cloud. Designed 25 years ago by New Mexico Tech, more than a dozen LMAs are now being operated across the globe. This talk will explain how I use Julia for processing LMA data processing, the visualization, and performance considerations. The power of Julia allows additional (novel) data analysis to be done while allowing a responsive interactive data browsing experience. The functionality of the LMA visualizer is already rich, and it is my intention to create a package for release to the greater community within a year or so. Background An LMA is a regional network of VHF antenna stations spaced 5-50 km apart that detect lightning pulses, typically in the 60-66 MHz band. The pulses are timed by GPS. Time-of-arrival reconstruction results in 3D pulse locations, revealing the lightning leader channels (of negative polarity) inside the cloud and toward ground. The detection range of a sensitive network can reach over 250 km from the center. More than a dozen LMAs are now operational world wide. They are used for lightning science, nowcasting of severe weather and airspace safety. In 2011, the Ebro 3D Lightning Mapping Array in Spain was the first LMA to be installed outside the USA, consisting of 12 stations in 2012-2014 and was subsequently split in half in 2015 to facilitate a LMA in Colombia. In 2023 and 2024, the system was upgraded to 15 stations spread out mostly across western Catalonia. It has detected very interesting cases of supercell storms with rising bubbles of lightning activity and even a “lightning hole” in hailstorms, as well as very large horizontal flashes that lasted for 6 seconds before they ceased, spanning 130 km. More information on the Ebro LMA, real-time monitoring and the eLMA services can be found at https://elma.upc.edu. An interactive lightning visualization and analysis tool for the LMA is being developed using Julia and Makie. It is a suite of tools that focus on (a) lightning flash analysis and general browsing of activity, (b) storm activity evolution analysis, and (c) network performance analysis based on the data. An automated leader speed tool was previously programmed in Scilab, using Theil-Sen slope estimator of points, which has been successfully implemented in Julia, reducing waiting times from many minutes to generally less than 10 seconds. Leader speed turns out to be the best tool for diagnosing the overall electrical charge structure of a thunderstorm. New tools include a flash grouping algorithm based on DBSCAN. Noisy points that do not belong to lightning leaders are filtered out, and these themselves can hold information which is subsequently going through another DBSCAN with different settings, to isolate sparse, local, but continuous activity such as sparks near the cloud top and sparks at wind turbines. Another DBSCAN setting allows to isolate the leader branches within flashes. The tool also can read cloud-to-ground stroke data from other networks, and Meteosat Third Generation Lightning Imager or GOES Geostationary Lightning Mapper (GLM) to be compared with LMA. A grid-based storm activity analysis tool has now been designed. It is based on local 3D flash density and its evolution in time visualizes trends in 3D activity, rather than the ubiquitously used general flash rate. It uses sparse arrays to manage memory issues, with certain performance considerations. Lightning leader speed, polarity and the repetition rate of leaders in flashes may hold new information that could turn out to be useful in monitoring the thunderstorm state and potential for severe weather. </video> <video> Solve Fractional Differential Equation with FractionalDiffEq.jl | Qu | JuliaCon 2024 Description: Solve Fractional Differential Equation with FractionalDiffEq.jl by Qingyu Qu PreTalx: https://pretalx.com/juliacon2024/talk/ZLG9BB/ Fractional-order differential equations have increasingly gained attention as a compelling subject, particularly in recent decades, offering more nuanced representations in natural models from a fractional-order perspective. Tracing back to the origins of 'non-integer' calculus, a concept first contemplated by Leibniz and L'Hôpital, numerous scientific luminaries have contributed tirelessly to the advancement of fractional calculus. This field has proven particularly instrumental in accurately describing phenomena in diverse areas such as viscoelasticity, acoustics, rheology, and polymeric chemistry. Additionally, the application of fractional derivatives has emerged as an exceptionally fitting approach for characterizing the memory and hereditary properties inherent in a variety of materials and processes. The SciML organization has achieved remarkable success in developing numerical solvers for differential equations. However, there are certain types of differential equations that [SciML has not yet supported](https://github.com/SciML/DifferentialEquations.jl/issues/461). Since the 20th century, fractional calculus and fractional differential equations have emerged as significant areas of interest in science and engineering, extending the principles of integer-order differential equations. Historically, most numerical software for these equations has been developed in MATLAB and suffered from a lack of consistent maintenance, leaving a gap for unified, user-friendly tools. Addressing this need, FractionalDiffEq.jl is an innovative package within the SciML ecosystem, integrating efficient algorithms specifically designed for fractional differential equations (FDEs). Leveraging the common interface of SciML, FractionalDiffEq.jl not only simplifies user interaction but also ensures seamless integration with other SciML packages. Currently, FractionalDiffEq.jl adeptly handles fractional order ordinary differential equations and delayed differential equations, representing a significant stride forward in computational science and engineering tools. The [FractionalDiffEq.jl](https://github.com/SciFracX/FractionalDiffEq.jl) package follows the design pattern of DifferentialEquations.jl. To solve a fractional differential equation problem, we first define a ```FDEProblem``` according to our model, use ```FODEProblem``` for common fractional ordinary differential equations, use ```FDDEProblem``` for delay fractional differential equations etc. Then pass the defined problem to ```solve``` function and choose an algorithm to solve our problem. ```julia prob = FDEProblem(fun, order, u0, tspan) sol = solve(prob, alg(), dt) ``` ```julia prob = FDDEProblem(fun, phi, order, u0, constant_lags=[tau], tspan) sol = solve(prob, alg(), dt) ``` There is still a long way to go for FractionalDiffEq.jl to become a mature package. We are working hard to improve the performance of the package and add more algorithms. The future plans included but not limited to: * Keep adding more high performance algorithms. * Make the usage of API more simple and elegant. * Write more illustrative documents for usability. * Integrate with the SciML ecosystem to provide users more useful features. </video> <video> What's new in Trustworthy AI in Julia (Taija)? | Altmeyer | JuliaCon 2024 Description: What's new in Trustworthy AI in Julia (Taija)? by Patrick Altmeyer PreTalx: https://pretalx.com/juliacon2024/talk/TJQJGZ/ Slides (PDF): https://pretalx.com/media/juliacon2024/submissions/TJQJGZ/resources/slides_mgdnhv2.pdf Github: https://github.com/JuliaTrustworthyAI Julia’s ecosystem for Artificial Intelligence (AI) and Machine Learning (ML) has been growing at a relatively rapid pace, perhaps most notably so in the [SciML](https://sciml.ai/) domain but also more broadly (e.g. [Flux](https://fluxml.ai/), [MLJ](https://juliaai.github.io/MLJ.jl/stable/), [JuliaGenAI](https://github.com/JuliaGenAI/juliagenai.org), …). The goal of Taija is to make AI models more trustworthy, where we have so far focused primarily on the interplay with packages in the latter category. **Please note**: This talk will *not* introduce various packages in great detail but instead focus on highlighting recent developments and research. If Taija is entirely new to you, I recommend you to check out these [slides](https://www.patalt.org/content/talks/posts/2024-turing/) that I recently presented at the Alan Turing Institute. They provide an accessible and relatively high-level overview of our core packages. ## 🏠 About Taija currently covers a range of approaches towards making AI systems more trustworthy: - Model Explainability ([CounterfactualExplanations.jl](https://github.com/JuliaTrustworthyAI/CounterfactualExplanations.jl)) - Algorithmic Recourse ([CounterfactualExplanations.jl](https://github.com/JuliaTrustworthyAI/CounterfactualExplanations.jl), [AlgorithmicRecourseDynamics.jl](https://github.com/JuliaTrustworthyAI/AlgorithmicRecourseDynamics.jl)) - Predictive Uncertainty Quantification ([ConformalPrediction.jl](https://github.com/JuliaTrustworthyAI/ConformalPrediction.jl), [LaplaceRedux.jl](https://github.com/JuliaTrustworthyAI/LaplaceRedux.jl)) - Effortless Bayesian Deep Learning ([LaplaceRedux.jl](https://github.com/JuliaTrustworthyAI/LaplaceRedux.jl)) - Hybrid Learning ([JointEnergyModels.jl](https://github.com/JuliaTrustworthyAI/JointEnergyModels.jl)) Various meta packages can be used to extend the core functionality: - Plotting ([TaijaPlotting.jl](https://github.com/JuliaTrustworthyAI/TaijaPlotting.jl)) - Datasets for testing and benchmarking ([TaijaData.jl](https://github.com/JuliaTrustworthyAI/TaijaData.jl)) - Parallelization ([TaijaParallel.jl](https://github.com/JuliaTrustworthyAI/TaijaParallel.jl)) - Interoperability with other programming languages ([TaijaInteroperability.jl](https://github.com/JuliaTrustworthyAI/TaijaInteroperability.jl)) The [TaijaBase.jl](https://github.com/JuliaTrustworthyAI/TaijaBase.jl) package provides common symbols, types and functions that are used across all or multiple Taija packages. ## 🛠️ Recent Developments A lot has happened since we presented some of our core packages at JuliaCon in 2022 and 2023. During the past year, the focus has been on extending and improving these existing packages. Various groups of undergraduate students at TU Delft as well as a few external collaborates have contributed to these efforts. ### CounterfactualExplanations.jl `CounterfactualExplanations.jl` is a package for Counterfactual Explanations and Algorithmic Recourse in Julia. - The code base has been streamlined to make it more accessible to new contributors. (students) - Part of this involved moving functionality out of the package into new meta-packages. (students) - Multiple new counterfactual generators including FeatureTweak for decision trees and random forests. (students) - Improved interoperability with Python and R through `TaijaInteroperability.jl`. (students) - Integration of ECCCo generator for faithful model explanations (Altmeyer et al. 2024). - Huge improvements to computational speed and native support for multi-threading and multi-processing. ### LaplaceRedux.jl `LaplaceRedux.jl` is a package for effortless Bayesian Deep Learning through Laplace Approximation for `Flux.jl` neural networks. - Support for multi-class problems. (students) - Support for more sophisticated and scalable Hessian approximations. (students) - Interface to MLJ for easy model training and evaluation. (students) ### Students’ Experience I will also briefly report back on the students’ experience working on these projects. This includes the challenges they faced, the skills they acquired, and the impact they had on the Taija ecosystem. ## 🎯 Ongoing and Future Projects Taija has been running two Julia Season of Code projects this summer. 1. (*Conformal Bayes*) Bridging the gap between Bayesian and frequentist approaches to Predictive Uncertainty Quantification. 2. (*Causal Recourse*) From minimal perturbations to minimal interventions for Algorithmic Recourse. Finally, we are also working with a group of students on [TaijaInteractive.jl](https://github.com/JuliaTrustworthyAI/TaijaInteractive.jl): a Genie-based web application for interactive model explanations. </video> <video> All that's new and improved in Optimization.jl | Dixit | JuliaCon 2024 Description: All that's new and improved in Optimization.jl by Vaibhav Dixit PreTalx: https://pretalx.com/juliacon2024/talk/KHPCUJ/ Though there have been a multitude of exciting developments in the package, in the talk I will highlight some that are unique and extremely useful. The EnsembleProblem interface of SciML for optimization problems allows any algorithm to be used with a multistart strategy. The intermediate optimization state and the final solver statistics are now uniform across the solver wrappers. The state is passed to the callback so users can create complex callbacks for logging, plotting or termination conditions. Advanced symbolic capabilities allow for features like automatic solver selection based on problem structure, alias elimination in problems with equality constraints and more. </video> <video> Seamless transition from single-core Python to Julia Multi-GPU | Omlin | JuliaCon 2024 Description: Seamless transition from single-core Python to Julia Multi-GPU by Samuel Omlin PreTalx: https://pretalx.com/juliacon2024/talk/N779AY/ Check points for correctness can be straightforwardly defined for ported and verified code blocks in order to later automatically signal potential issues that manifest due to refactoring work or consideration of new input classes. We have demonstrated the approach's effectiveness in a real-world use case, a collaboration between domain scientists and HPC experts in the scope of Europe's Human Brain Project (HBP). Based on a single-CPU-core Python prototype developed by the domain scientists, we have jointly created a Julia application for Bayesian optimization of hyper-parameters of a neurological network that is deployable on the world's largest GPU supercomputers and achieves near optimal performance and scaling. Furthermore, as a result of the automatic correctness verification, the domain scientists - with no previous Julia experience - could quickly gain confidence in the ported Julia application, which is an important aspect in HPC collaboration projects as the presented one. The Julia application serves the domain scientists now also for further prototyping: leveraging [ParallelStencil.jl](https://github.com/omlins/ParallelStencil.jl) has made it feasible to fully unify prototyping and production in a single code that is deployable on a single CPU core or thousands of GPUs. </video> <video> SummaryTables: Publication-ready tables in docx HTML LaTeX Typst | Krumbiegel | JuliaCon 2024 Description: SummaryTables: Publication-ready tables in docx HTML LaTeX Typst by Julius Krumbiegel PreTalx: https://pretalx.com/juliacon2024/talk/KZNFPS/ The workflows of many pharma companies we work with at PumasAI involve creating reports in a mixture of formats: HTML, pdf via LaTeX and Typst, or docx files which are often the easiest way to quickly edit together the assets our users need at any given moment. While general-purpose tools like pandoc allow targetting many output formats, including HTML, pdf and docx, style information is usually lost in translation. This was not good enough for our purposes, we wanted a tool to create our tables with the same look across all formats. This requirement also prompted the development of WriteDocx.jl, which through its detailed mapping of the actual docx XML spec, allows creating docx files with much higher precision than using a generic conversion tool. The other purpose of SummaryTables.jl is to offer a collection of statistical table formats that are commonly found in pharma-related workflows. Currently, we have implemented listing tables, parameter summary tables and what's commonly called a "table 1" in our field. With the open-sourcing of SummaryTables.jl and WriteDocx.jl, we want to contribute back to the Julia ecosystem and strengthen its arsenal of utility packages which are useful in the pharma world and beyond. </video> <video> SeismicWaves.jl: a wave simulation package for FWI on multi-xPUs | Aloisi | JuliaCon 2024 Description: SeismicWaves.jl: a wave simulation package for FWI on multi-xPUs by Giacomo Aloisi PreTalx: https://pretalx.com/juliacon2024/talk/TGQYQX/ Presentation Slides: https://pretalx.com/media/juliacon2024/submissions/TGQYQX/resources/JuliaCon24_Presentation_USflzWK.pdf The package is based on finite-difference methods for solving the wave equation in parallel and distributed systems using [ParallelStencil.jl](https://github.com/omlins/ParallelStencil.jl) and [ImplicitGlobalGrid.jl](https://github.com/eth-cscs/ImplicitGlobalGrid.jl), enabling seamless multi-xPU computing. Rigorous benchmarks and synthetic inversions validate the solvers' correctness while achieving high memory throughput (up to 90% of peak) on modern GPUs and exhibiting good weak scaling on distributed systems. In conclusion, [SeismicWaves.jl](https://gitlab.com/JuliaGeoph/SeismicWaves.jl) provides easy-to-use and efficient solvers to bridge the gap between theory and practice for a variety of FWI applications and use cases, from fast prototyping on a laptop to high-resolution, large-scale simulations on supercomputing clusters. </video> <video> Real‑Time Airborne Magnetic Navigation with MagNav.jl | Taylor, R. Gnadt | JuliaCon 2024 Description: Real‑Time Airborne Magnetic Navigation with MagNav.jl by Jonathan Taylor, Albert R. Gnadt PreTalx: https://pretalx.com/juliacon2024/talk/GBHW7G/ The final talk of the MagNav.jl JuliaCon series will discuss the development and options for real-time compensation and navigation, which is important for real-world implementation. At a high level, MagNav.jl provides tooling to compensate for an aircraft’s magnetic field, removing most of the corruption to enable comparing magnetometer readings with detailed maps of the Earth’s magnetic field. It can then use the resultant signal, alongside other readings, as input to a navigation filter, such as an extended Kalman filter, in order to estimate position. Julia is integral to our research in this field due to its specialties in automatic differentiation, ease of neural network construction, and its performance. This talk will showcase how state-of-the-art (Tolles-Lawson) and machine learning aeromagnetic compensation models can be implemented for real-time compensation, otherwise known as online aeromagnetic compensation. Navigation performance for these approaches will also be compared with the standard (not online) models. </video> <video> Build real-time processes with Pluto's reactivity | Sahm | JuliaCon 2024 Description: Build real-time processes with Pluto's reactivity by Stephan Sahm PreTalx: https://pretalx.com/juliacon2024/talk/TVDJ3H/ PlutoHooks.jl has been out for quite some time, but not many know about these hidden Pluto gems. While PlutoUI is about client-side triggers, PlutoHooks is about server-side triggers, also called self-updates. Actually the mechanism is built into Pluto itself. This talk I will showcase a concrete example: Applying RxInfer.jl for real time probabilistic prediction of financial bitcoin data. </video> <video> On physics-informed automatic differentiation | Schmitz | JuliaCon 2024 Description: On physics-informed automatic differentiation by Niklas Schmitz PreTalx: https://pretalx.com/juliacon2024/talk/8AJJ9U/ The growing availability of automatic differentiation (AD) tools promises numerous applications for enhancing large-scale scientific simulations, from sensitivity analysis to machine learning. However, the interplay of AD ("the gradient you get") and numerical analysis, implicit differentiation and physical symmetries ("the gradient you want") is nontrivial. I will briefly present such considerations on examples from materials science (density-functional theory) in DFTK.jl. </video> <video> Hydrological modelling in Julia with Wflow.jl and Ribasim.jl | Visser, Pronk | JuliaCon 2024 Description: Hydrological modelling in Julia with Wflow.jl and Ribasim.jl by Martijn Visser, Maarten Pronk PreTalx: https://pretalx.com/juliacon2024/talk/MXMMSW/ Slides: https://pretalx.com/media/juliacon2024/submissions/MXMMSW/resources/Hydrological_modeling_in_Julia_with_Wflow_and__tUsc0EM.pdf GitHub: https://github.com/Deltares/Ribasim GitHub: https://github.com/Deltares/Wflow.jl At Deltares, an applied research institute in the Netherlands, we (re)developed two open-source hydrological numerical models. Wflow is Deltares’ solution for modelling hydrological processes, allowing users to account for precipitation, interception, snow accumulation and melt, evapotranspiration, soil water, surface water and groundwater recharge in a fully distributed environment. Ribasim is a water resources model. It allows users to model basins under current and changing conditions to evaluate and design the water system. Julia solved the two-language problem for us. Wflow was originally written in Python, linked to an external C++ library (PCRaster). Rewriting in Julia yielded more freedom and performance. Ribasim was originally written in Fortran, and the move to Julia resulted in clearer, faster and less code, especially because we use the existing solvers from DifferentialEquations.jl and JuMP.jl. However, while Julia solved the two-language problem for numerical simulation software for us, bridging hydrologists and software-engineers, we find that most end-users/modellers stick to Python for scripting. We therefore decided to write most of the pre- and post-processing code in Python for now. We discuss what’s still needed in the Julia ecosystem to also take this hurdle. </video> <video> Improving the life-cycle of tensor algorithm development | pierce | JuliaCon 2024 Description: Improving the life-cycle of tensor algorithm development by karl pierce PreTalx: https://pretalx.com/juliacon2024/talk/J39XGJ/ As the accessibility to advanced computational resources, such as CPU, GPU, and QPU, becomes common to researchers across theoretical and computational disciplines, it is more important than ever to construct robust and generic software frameworks that can facilitate rapid algorithmic development on such resources. One of the biggest challenges researchers have faced in algorithmic development is the complexity of exascale and heterogeneous computer architectures. Some challenges are quite complex, such as constructing efficient memory-distributed algorithms, while others are simple yet cumbersome, such as the syntactic differences in vendor-developed, processor-specific languages. In our most recent efforts in the ITensors software suite, we are attempting to tackle these issues head-on using generic programming. The goal of the ITensors package is to create a domain-specific language for tensor arithmetic and tensor algebra built from the ground up using Julia's robust features in coordination with thoughtful generic programming practices. ITensors is the meeting point between the lower-level tensor implementation and the higher-level, problem-specific algorithm development. In this talk, I will focus on the low-level implementation in the NDTensors module where we are developing generic practices to handle implementation complexities such as dense and sparse tensor arithmetic, buffered memory management, linear and multilinear algebra, GPU implementations, task-management and scheduling, and beyond. We underscore the power of our generic programming strategy by showing multiple methods for accelerating the DMRG optimization of the one- and two-dimensional Hubbard and Heisenberg models, which require only a small number of changes to existing ITensor code and can take advantage of GPU accelerators. </video> <video> SpeciesDistributionModels.jl: an SDM workflow | Schouten, van der Deure | JuliaCon 2024 Description: SpeciesDistributionModels.jl: an SDM workflow by Rafael Schouten, Tiem van der Deure PreTalx: https://pretalx.com/juliacon2024/talk/P88SPE/ The accessibility of species distribution modelling techniques through R packages such as sdm and biomod2 has hugely contributed to their popularity. The paper that introduces maxent (https://doi.org/10.1016/j.ecolmodel.2005.03.026), one of the most popular algorithms for species distribution modelling, has been cited over 18 thousand times. SpeciesDistributionModels.jl is designed to be as user-friendly as existing R-based platforms, but with the power of Julia. It builds on the MLJ ecosystem can be extended with any MLJ-compatible model that accepts a binary response variable. It also integrates with Rasters.jl and Makie.jl to predict with geospatial inputs and outputs and for easy visualisation of model evaluation. The speed-up provided by Julia opens up new possibilities to explore and visualise SDMs, like using Shapley values for more adequately explain the contributions of predictor variables and interactive plotting. This talk will show a typical SDM workflow using SpeciesDistributionModels.jl and discuss the advantages of using Julia for SDMs. </video> <video> Profile Likelihood-based Practical Identifiability in Julia | Borisov | JuliaCon 2024 Description: Profile Likelihood-based Practical Identifiability in Julia by Ivan Borisov PreTalx: https://pretalx.com/juliacon2024/talk/MVFTEK/ GitHub: https://github.com/insysbio/LikelihoodProfiler.jl Practical identifiability of Systems Biology models has received a lot of attention in recent scientific research. It addresses the crucial question of models’ reliability: how accurately can the parameters of the model be recovered from the available experimental data. Noisy or incomplete data result in uncertainty in parameters estimations typically described by confidence intervals and confidence regions. The methods based on profiling the likelihood function are among the most reliable and widely used approaches to estimate parameters’ confidence intervals and state their practical identifiability. The application of Profile Likelihood-based methods can also be extended to predictability analysis and confidence bands estimation. With the growing interest of Systems Biology community to Julia and SciML package ecosystem it is fair to ask what methods are available to address the problem of practical identifiability and predictability in Julia. The talk will present the problem of practical identifiability and propose an overview of available packages (LikelihoodProfiler.jl and ProfileLikelihood.jl) and the desirable improvements to Julia SciML ecosystem. </video> <video> MaxEntropyGraphs.jl: Random Graphs with JuliaGraphs | De Clerck | JuliaCon 2024 Description: MaxEntropyGraphs.jl: Random Graphs with JuliaGraphs by Bart De Clerck PreTalx: https://pretalx.com/juliacon2024/talk/PFAA8M/ Network analysis is a powerful tool for understanding the structure and function of complex systems, such as social networks, ecological networks, and biological networks. By examining the connections and interactions between nodes in a network, researchers can gain insights into the underlying processes and patterns that govern these systems. These real-world systems or networks can be represented by the mathematical object that is a graph. Graph randomization is a method commonly used in network analysis to establish null hypotheses and compare an observed graph against random expectations within an ensemble of graphs. For example, graph randomization can be used to investigate whether a particular network exhibits a higher level of clustering than expected by chance, which can provide insights into the presence of community structures within the network. There are many ways to do graph randomization, but maximum entropy null models are specifically useful due to their unbiased parameter estimation, incorporation of constraints, flexibility, statistical robustness, and mathematical simplicity. The MaxEntropyGraphs.jl package can be used to compute the likelihood-maximizing parameters for different null models for a variety of graphs (directed, undirected, bipartite, weighted etc.). It enables users to sample graphs from the ensemble and to compute the expected value of a graph metric directly from the ensemble. The package uses the JuliaGraphs ecosystems for everything graph related, makes us of well-established Julia optimization tools (Optimization.jl) and numerical solvers (NLsolve.jl) to obtain the graph’s likelihood maximizing parameters; leverages the JuliaDiff ecosystem for automatic differentiation and groups the different null models in a single framework. Currently, there are no existing Julia packages offering this functionality. In Python, there are some packages that provide similar functionality (NEMtropy, BiCM, etc.), but these do not always integrate directly with an established Python ecosystem for graphs, use a custom implementation for the numerical solver(s), and do not offer the possibility of using automatic differentiation. Performance testing has shown that the Julia implementation is typically faster than the equivalent Python packages for networks of different sizes and densities. The way forward for this package is to include additional null models that might be relevant for more advanced concepts such as higher-order or multilayer graphs. </video>

Contacts and Links

Description

Julia is a high-performance, dynamic programming language for modern technical computing. It solves the two language problem by being simultaneously as fast as C and as easy as Python. The built-in package manager provides access to over 6,000 Julia packages created by the Julia community, in addition to foreign function interfaces for tens of thousands of C, Fortran, Python, and R libraries.

The Julia package ecosystem includes best in class packages in a number of ecosystems: Image Processing, Machine Learning, Data Science, Optimization, Parallel computing, Cloud computing, Automatic Differentiation, Graph Processing, Probabilistic Programming, Finite Elements, Computational Biology, Ecology, Climate science, Astrophysics, Quantum Computing, and much more.

Videos from channel