nx VS axon

Compare nx vs axon and see what are their differences.

nx

Multi-dimensional arrays (tensors) and numerical definitions for Elixir (by elixir-nx)
Our great sponsors
  • WorkOS - The modern identity platform for B2B SaaS
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • SaaSHub - Software Alternatives and Reviews
nx axon
36 15
2,447 1,432
1.9% 2.0%
9.4 7.8
11 days ago 15 days ago
Elixir Elixir
- Apache License 2.0
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
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.

nx

Posts with mentions or reviews of nx. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-08-25.

axon

Posts with mentions or reviews of axon. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-04-14.
  • Data wrangling in Elixir with Explorer, the power of Rust, the elegance of R
    7 projects | news.ycombinator.com | 14 Apr 2023
    José from the Livebook team. I don't think I can make a pitch because I have limited Python/R experience to use as reference.

    My suggestion is for you to give it a try for a day or two and see what you think. I am pretty sure you will find weak spots and I would be very happy to hear any feedback you may have. You can find my email on my GitHub profile (same username).

    In general we have grown a lot since the Numerical Elixir effort started two years ago. Here are the main building blocks:

    * Nx (https://github.com/elixir-nx/nx/tree/main/nx#readme): equivalent to Numpy, deeply inspired by JAX. Runs on both CPU and GPU via Google XLA (also used by JAX/Tensorflow) and supports tensor serving out of the box

    * Axon (https://github.com/elixir-nx/axon): Nx-powered neural networks

    * Bumblebee (https://github.com/elixir-nx/bumblebee): Equivalent to HuggingFace Transformers. We have implemented several models and that's what powers the Machine Learning integration in Livebook (see the announcement for more info: https://news.livebook.dev/announcing-bumblebee-gpt2-stable-d...)

    * Explorer (https://github.com/elixir-nx/explorer): Series and DataFrames, as per this thread.

    * Scholar (https://github.com/elixir-nx/scholar): Nx-based traditional Machine Learning. This one is the most recent effort of them all. We are treading the same path as scikit-learn but quite early on. However, because we are built on Nx, everything is derivable, GPU-ready, distributable, etc.

    Regarding visualization, we have "smart cells" for VegaLite and MapLibre, similar to how we did "Data Transformations" in the video above. They help you get started with your visualizations and you can jump deep into the code if necessary.

    I hope this helps!

  • Elixir and Rust is a good mix
    10 projects | news.ycombinator.com | 13 Apr 2023
    > I guess, why not use Rust entirely instead of as a FFI into Elixir or other backend language?

    Because Rust brings none of the benefits of the BEAM ecosystem to the table.

    I was an early Elixir adopter, not working currently as an Elixir developer, but I have deployed one of the largest Elixir applications for a private company in my country.

    I know it has limits, but the language itself is only a small part of the whole.

    Take ML, Jose Valim and Sean Moriarity have studied the problem, made a plan to tackle it and started solving it piece by piece [1] in a tightly integrated manner, it feels natural, as if Elixir always had those capabilities in a way that no other language does and to put the icing on the cake the community released Livebook [2] to interactively explore code and use the new tools in the simplest way possible, something that Python notebooks only dream of being capable of, after a decade of progress

    That's not to say that Elixir is superior as a language, but that the ecosystem is flourishing and the community is able to extract the 100% of the benefits from the tools and create new marvellously crafted ones, that push the limits forward every time, in such a simple manner, that it looks like magic.

    And going back to Rust, you can write Rust if you need speed or for whatever reason you feel it's the right tool for the job, it's totally integrated [3][4], again in a way that many other languages can only dream of, and it's in fact the reason I've learned Rust in the first place.

    The opposite is not true, if you write Rust, you write Rust, and that's it. You can't take advantage of the many features the BEAM offers, OTP, hot code reloading, full inspection of running systems, distribution, scalability, fault tolerance, soft real time etc. etc. etc.

    But of course if you don't see any advantage in them, it means you probably don't need them (one other option is that you still don't know you want them :] ). In that case Rust is as good as any other language, but for a backend, even though I gently despise it, Java (or Kotlin) might be a better option.

    [1] https://github.com/elixir-nx/nx https://github.com/elixir-nx/axon

    [2] https://livebook.dev/

    [3] https://github.com/rusterlium/rustler

    [4] https://dashbit.co/blog/rustler-precompiled

  • Bumblebee: GPT2, Stable Diffusion, and More in Elixir
    5 projects | news.ycombinator.com | 8 Dec 2022
    I've trained models using Jupyter and Livebook (though only smaller toy models [1]) so I can deposit my 2 cents here. Small disclaimer that I started with Jupyter, so in some sense my mental model was biased towards Jupyter.

    I think the biggest difference that'll trip you up coming from Jupyter is that Livebook enforces linear execution. You can't arbitrarily run cells in any order like you can in Jupyter - if you change an earlier cell all the subsequent cells have to be run in order. The only deviation from this is branches which allow you to capture the state at a certain point and create a new flow from there on. There's a section in [1] that explains how branching works and how you can use it when training models.

    The other difference is that if you do something that crashes in a cell, you'll lose the state of the entire branch and have to rerun from the beginning of the branch. Iirc if you stop a long running cell, that forces a rerun as well. That can also be painful when running training loops that run for a while, but there are some pretty neat workarounds you can do using Kino. Using those workarounds does break the reproducibility guarantees though.

    Personally while building NN models I find that I prefer the Jupyter execution model because for NNs, rerunning cells can be really time-consuming. Being able to quickly change some variables and run a cell out of order helps while I'm exploring/experimenting.

    Two things I love about Livebook though are 1) the file format makes version control super easy and 2) Kino allows for real interactivity in the notebook in a way that's much harder to do in Jupyter. So in Livebook you can easily create live updating charts, images etc that show training progress or have other kinds of interactivity.

    If you're interested to see what my model training workflow looks like with Livebook (and I have no idea if it's the best workflow!), check out the examples below [1][2]. Overall I'd say it definitely works well, you just have to shift your mental model a bit if you're coming from Jupyter. If I were doing something where rerunning cells wasn't expensive I would probably prefer the Livebook model.

    [1] https://github.com/elixir-nx/axon/blob/main/notebooks/genera...

  • ElixirConf 2022 - That's a wrap!
    7 projects | dev.to | 12 Sep 2022
    Machine learning is rapidly expanding within the Elixir ecosystem, with tools such as Nx, Axon, and Explorer being used both by individuals and companies such as Amplified, as mentioned above.
  • What's your opinion on Elixir?
    3 projects | /r/rust | 20 May 2022
    It's my professional daily driver since 2018 but I consider it an average-to-disappointing language and ecosystem on top of an incredible VM/runtime. For more specific thoughts, back in 2020 I've previously posted some critique here and very little of these concerns are improved in the interim. There is a vestigial ML story around libraries like Nx/Axon. LiveView is inadvisable in practice but is sort of the banner marketing device right now, which disappoints me.
  • Recognize Digits Using ML in Elixir
    2 projects | /r/elixir | 11 May 2022
    Yeah, as Mark said, I think the problem is related to this issue https://github.com/elixir-nx/axon/issues/244
  • Do Elixir's benefits still hold when interfacing with another language?
    2 projects | /r/elixir | 2 May 2022
  • Show HN: Dataframes in Elixir Backed by Rust
    6 projects | news.ycombinator.com | 4 Nov 2021

What are some alternatives?

When comparing nx and axon you can also consider the following projects:

Elixir - Elixir is a dynamic, functional language for building scalable and maintainable applications

gleam - ⭐️ A friendly language for building type-safe, scalable systems!

dplyr - dplyr: A grammar of data manipulation

explorer - An open source block explorer

fib - Performance Benchmark of top Github languages

livebook - Automate code & data workflows with interactive Elixir notebooks

clojerl - Clojure for the Erlang VM (unofficial)

meander - Tools for transparent data transformation

ClojureCLR - A port of Clojure to the CLR, part of the Clojure project

protocol_ex - Elixir Extended Protocol

evision - Evision: An OpenCV-Erlang/Elixir binding

explorer - Series (one-dimensional) and dataframes (two-dimensional) for fast and elegant data exploration in Elixir