Optimization.jl
Enzyme
Optimization.jl | Enzyme | |
---|---|---|
3 | 16 | |
663 | 1,159 | |
2.1% | 1.6% | |
9.7 | 9.7 | |
6 days ago | 4 days ago | |
Julia | LLVM | |
MIT License | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
Optimization.jl
-
SciPy: Interested in adopting PRIMA, but little appetite for more Fortran code
Interesting response. I develop the Julia SciML organization https://sciml.ai/ and we'd be more than happy to work with you to get wrappers for PRIMA into Optimization.jl's general interface (https://docs.sciml.ai/Optimization/stable/). Please get in touch and we can figure out how to set this all up. I personally would be curious to try this out and do some benchmarks against nlopt methods.
-
Help me to choose an optimization framework for my problem
There are also Optimization and Nonconvex , which seem like umbrella packages and I am not sure what methods to use inside these packages. Any help on these?
-
The Julia language has a number of correctness flaws
> but would you say most packages follow or enforce SemVer?
The package ecosystem pretty much requires SemVer. If you just say `PackageX = "1"` inside of a Project.toml [compat], then it will assume SemVer, i.e. any version 1.x is non-breaking an thus allowed, but not version 2. Some (but very few) packages do `PackageX = ">=1"`, so you could say Julia doesn't force SemVar (because a package can say that it explicitly believes it's compatible with all future versions), but of course that's nonsense and there will always be some bad actors around. So then:
> Would enforcing a stricter dependency graph fix some of the foot guns of using packages or would that limit composability of packages too much?
That's not the issue. As above, the dependency graphs are very strict. The issue is always at the periphery (for any package ecosystem really). In Julia, one thing that can amplify it is the fact that Requires.jl, the hacky conditional dependency system that is very not recommended for many reasons, cannot specify version requirements on conditional dependencies. I find this to be the root cause of most issues in the "flow" of the package development ecosystem. Most packages are okay, but then oh, I don't want to depend on CUDA for this feature, so a little bit of Requires.jl here, and oh let me do a small hack for OffSetArrays. And now these little hacky features on the edge are both less tested and not well versioned.
Thankfully there's a better way to do it by using multi-package repositories with subpackages. For example, https://github.com/SciML/GalacticOptim.jl is a global interface for lots of different optimization libraries, and you can see all of the different subpackages here https://github.com/SciML/GalacticOptim.jl/tree/master/lib. This lets there be a GalacticOptim and then a GalacticBBO package, each with versioning, but with tests being different while allowing easy co-development of the parts. Very few packages in the Julia ecosystem actually use this (I only know of one other package in Julia making use of this) because the tooling only recently was able to support it, but this is how a lot of packages should be going.
The upside too is that Requires.jl optional dependency handling is by far and away the main source of loading time issues in Julia (because it blocks precompilation in many ways). So it's really killing two birds with one stone: decreasing package load times by about 99% (that's not even a joke, it's the huge majority of the time for most packages which are not StaticArrays.jl) while making version dependencies stricter. And now you know what I'm doing this week and what the next blog post will be on haha.
Enzyme
-
Show HN: Curve Fitting Bezier Curves in WASM with Enzyme Ad
Automatic differentiation is done using https://enzyme.mit.edu/
-
Ask HN: What Happened to TensorFlow Swift
lattner left google and was the primary reason they chose swift, so they lost interest.
if you're asking from an ML perspective, i believe the original motivation was to incorporate automatic differentiation in the swift compiler. i believe enzyme is the spiritual successor.
https://github.com/EnzymeAD/Enzyme
-
Show HN: Port of OpenAI's Whisper model in C/C++
https://ispc.github.io/ispc.html
For the auto-differentiation when I need performance or memory, I currently use tapenade ( http://tapenade.inria.fr:8080/tapenade/index.jsp ) and/or manually written gradient when I need to fuse some kernel, but Enzyme ( https://enzyme.mit.edu/ ) is also very promising.
MPI for parallelization across machines.
-
Do you consider making a physics engine (for RL) worth it?
For autodiff, we are currently working again on publishing a new Enzyme (https://enzyme.mit.edu) Frontend for Rust which can also handle pure Rust types, first version should be done in ~ a week.
-
What is a really cool thing you would want to write in Rust but don't have enough time, energy or bravery for?
Have you taken a look at enzymeAD? There is a group porting it to rust.
-
The Julia language has a number of correctness flaws
Enzyme dev here, so take everything I say as being a bit biased:
While, by design Enzyme is able to run very fast by operating within the compiler (see https://proceedings.neurips.cc/paper/2020/file/9332c513ef44b... for details) -- it aggressively prioritizes correctness. Of course that doesn't mean that there aren't bugs (we're only human and its a large codebase [https://github.com/EnzymeAD/Enzyme], especially if you're trying out newly-added features).
Notably, this is where the current rough edges for Julia users are -- Enzyme will throw an error saying it couldn't prove correctness, rather than running (there is a flag for "making a best guess, but that's off by default"). The exception to this is garbage collection, for which you can either run a static analysis, or stick to the "officially supported" subset of Julia that Enzyme specifies.
Incidentally, this is also where being a cross-language tool is really nice -- namely we can see edge cases/bug reports from any LLVM-based language (C/C++, Fortran, Swift, Rust, Python, Julia, etc). So far the biggest code we've handled (and verified correctness for) was O(1million) lines of LLVM from some C++ template hell.
I will also add that while I absolutely love (and will do everything I can to support) Enzyme being used throughout arbitrary Julia code: in addition to exposing a nice user-facing interface for custom rules in the Enzyme Julia bindings like Chris mentioned, some Julia-specific features (such as full garbage collection support) also need handling in Enzyme.jl, before Enzyme can be considered an "all Julia AD" framework. We are of course working on all of these things (and the more the merrier), but there's only a finite amount of time in the day. [^]
[^] Incidentally, this is in contrast to say C++/Fortran/Swift/etc, where Enzyme has much closer to whole-language coverage than Julia -- this isn't anything against GC/Julia/etc, but we just have things on our todo list.
-
Jax vs. Julia (Vs PyTorch)
Idk, Enzyme is pretty next gen, all the way down to LLVM code.
https://github.com/EnzymeAD/Enzyme
-
What's everyone working on this week (7/2022)?
I'm working on merging my build-tool for (oxide)-enzyme into Enzyme itself. Also looking into improving the documentation.
- Wsmoses/Enzyme: High-performance automatic differentiation of LLVM
-
Trade-Offs in Automatic Differentiation: TensorFlow, PyTorch, Jax, and Julia
that seems one of the points of enzyme[1], which was mentioned in the article.
[1] - https://enzyme.mit.edu/
being able in effect do interprocedural cross language analysis seems awesome.
What are some alternatives?
StatsBase.jl - Basic statistics for Julia
Zygote.jl - 21st century AD
Petalisp - Elegant High Performance Computing
Flux.jl - Relax! Flux is the ML library that doesn't make you tensor
OffsetArrays.jl - Fortran-like arrays with arbitrary, zero or negative starting indices.
Pytorch - Tensors and Dynamic neural networks in Python with strong GPU acceleration
avm - Efficient and expressive arrayed vector math library with multi-threading and CUDA support in Common Lisp.
Lux.jl - Explicitly Parameterized Neural Networks in Julia
Distributions.jl - A Julia package for probability distributions and associated functions.
linfa - A Rust machine learning framework.
StaticLint.jl - Static Code Analysis for Julia
faust - Functional programming language for signal processing and sound synthesis