twitter:title

description

twitter:description

https://www.datocms-assets.com/55475/1716517299-alembic-logo-stacked-solid-3-1.svg?auto=format&fit=max&w=1200

twitter:image

twitter:card

twitter:site

You'll be first to know when we've published the next newsletter

Thank you! You're subscribed to our newsletter

Phoenix LiveView is a game changer for dynamic web application development. But what happens when we get serious traffic, and things slow down? What if we have some ambitious concurrency and latency requirements?

Monitoring Phoenix LiveView performance

<p>Numerical performance of Elixir code has received a massive boost with the release of Nx - Numerical Elixir.</p>

<p>Over the past few months José Valim has been dropping cryptic hints about an exciting, but mysterious new Elixir project called Nx. A series of tweets, alluding to big performance improvements got the community speculating as to what Nx could be.</p>

<p>The wait was finally over on Feb 9th, when on the <a href="https://thinkingelixir.com/podcast-episodes/034-jose-valim-reveals-project-nx/">Thinking Elixir</a> podcast, all was revealed.  Nx is Numerical Elixir, a tensor programming library for Elixir.  With Nx, we can develop tensor (multi-dimensional array) programs in Elixir and use a much faster backend to run them on the CPU or GPU. This is very exciting as it opens up a whole new set of use cases for Elixir in data science and machine learning and other numerically focussed workloads.</p>

<p>A new numerical function definition keyword, <code>defn</code>, is also introduced, wherein we can use a large subset of Elixir syntax to develop Nx programs.  Numerical definitions are compiled to computation graphs that describe the operations we want to perform, which are in turn compiled to efficient CPU or GPU code.  Early benchmarks show several orders of magnitude performance gains over plain Elixir, in some cases there are speed improvements of almost 5000x!</p>

<h3>Numbats and Numerical Notebooks?</h3>

<p>As a nice touch for us Australian alchemists, the mascot of the Nx project is the <a href="https://en.wikipedia.org/wiki/Numbat">numbat</a>, a native Australian marsupial.  The official Nx code repo on GitHub also has a cute <a href="https://github.com/elixir-nx/nx/raw/main/nx/nx.png">numbat logo</a>.</p>

<p>To see what all the fuss is about, Robert from Alembic (<a href="https://twitter.com/robertellen">@robertellen</a>) developed a code notebook that explores the Nx API, and presented the notebook at the Elixir Australia March meetup.</p>

<ul>
<li>The video of the talk is now up on <a href="https://www.youtube.com/watch?v=SgSbaGm5nR0">YouTube</a></li>
<li>The repository hosting the code notebook is available on <a href="https://github.com/team-alembic/elixir_nx_demo">Github</a>.</li>
</ul>

<p>You&#39;ll need to download the code notebook and run as a Phoenix LiveView application locally as this isn&#39;t protected against arbitrary code execution (so we can&#39;t host it yet). José has been recently hinting at the possibility of hosted notebooks though, so this may be possible soon? </p>

<h3>Tensors are multi dimensional arrays</h3>

<p>Nx, at its core, is tensor programming library.  In the context of Nx, tensors are multi-dimensional arrays.  For anyone familiar with <a href="https://www.tensorflow.org/">TensorFlow</a>, <a href="https://pytorch.org/">PyTorch</a>, or <a href="https://numpy.org/">NumPy</a>, tensors in Nx are equivalent to the tensors or multi-dimensional arrays in those environments.</p>

<p>To begin working with Nx, tensors are created from nested lists as well as binaries, and <code>Nx.reshape</code> allows a shape to be given to a flat binary.</p>

<pre><code class="elixir">iex(1)&gt; Nx.tensor([[1,2,3],[4,5,6]])
#Nx.Tensor&lt;
  s64[2][3]
  [
    [1, 2, 3],
    [4, 5, 6]
  ]
&gt;
</code></pre>

<pre><code class="elixir">iex(1)&gt; t = Nx.from_binary(&lt;&lt;1::integer,2::integer,3::integer,4::integer&gt;&gt;, {:u,8})
#Nx.Tensor&lt;
  u8[4]
  [1, 2, 3, 4]
&gt;
iex(2)&gt; t |&gt; Nx.reshape({2,2})
#Nx.Tensor&lt;
  u8[2][2]
  [
    [1, 2],
    [3, 4]
  ]
&gt;
</code></pre>

<p>Tensors can also be created from shapes (e.g. <code>{2,3}</code> for a 2-by-3 array) in a variety of ways with functions such as <code>Nx.iota</code> (creates an array of values incrementing from zero) or <code>Nx.broadcast</code> (adds dimensions to an array by duplicating the data in the array).</p>

<h3>Tensor-aware functions</h3>

<p>In Nx, we don&#39;t have to write loops over the elements of our tensors like we would if they were lists or maps.  A broad range of <em>tensor-aware</em> functions exist in the Nx library that will perform operations on tensors without explicit loops (maps or reduces).  This both makes the code terse and more performant.</p>

<p>Examples of tensor-aware functions are:</p>

<ul>
<li>unary functions such as <code>Nx.exp</code></li>
</ul>

<pre><code class="elixir">iex(16)&gt; [[1.0, 2.0],[3.0,4.0]] |&gt; Nx.tensor |&gt; Nx.exp
#Nx.Tensor&lt;
  f32[2][2]
  [
    [2.7182817459106445, 7.389056205749512],
    [20.08553695678711, 54.598148345947266]
  ]
&gt;
</code></pre>

<ul>
<li>binary functions such as <code>Nx.add</code></li>
</ul>

<pre><code class="elixir">iex(1)&gt; Nx.add(Nx.tensor([1,2,3,4]), Nx.tensor([5,6,7,8]))
#Nx.Tensor&lt;
  s64[4]
  [6, 8, 10, 12]
&gt;
</code></pre>

<ul>
<li>and, aggregate functions such as <code>Nx.sum</code></li>
</ul>

<pre><code class="elixir">iex(1)&gt; [[1.0,2.0],[3.0,4.0]] |&gt; Nx.tensor |&gt; Nx.sum
#Nx.Tensor&lt;
  f32
  10.0
&gt;
</code></pre>

<p>The tensor-aware operations are the key to the potential speed-ups that Nx provides.  Each backend for Nx implements efficient versions of the operations that execute in parallel.</p>

<p>Further to an API of tensor operations, Nx introduces Numerical Definitions to make developing tensor code more natural.  By defining a function with <code>defn</code> instead of the usual <code>def</code>, we can write tensor code using a broad subset of Elixir syntax, including tensor-aware version of operators we know from <code>Kernel</code>, such as <code>+</code>, <code>-</code>, <code>*</code>, and <code>/</code>.  The canonical example of using numerical definitions is the <code>softmax</code> function:</p>

<pre><code class="elixir">defmodule Formula do
  import Nx.Defn

  defn softmax(t) do
    Nx.exp(t) / Nx.sum(Nx.exp(t))
  end
end
</code></pre>

<h3>Easily Configurable Backends</h3>

<p>Currently, the Nx contributors have implemented backends for Nx in EXLA and Torchx, which are Elixir clients for Google&#39;s XLA (Accelerated Linear Algebra), and LibTorch, respectively.  Both support CPU or GPU-based acceleration of Nx functions and numerical definitions, and below we can see how easy it is to specify different backend configurations globally or even per tensor.</p>

<pre><code class="elixir">Nx.tensor([1,2,3,4], backend: Torchx.Backend)

@default_defn_compiler {EXLA, run_options: [keep_on_device: true]}
</code></pre>

<h3>Benchmarks show 5000x speed boost!</h3>

<p>The Nx <a href="https://github.com/elixir-nx/nx">GitHub repo</a> presents a nice benchmark for the softmax numerical definition:</p>

<pre><code class="graphql">Comparison:
xla gpu f32 keep      15308.14
xla gpu f64 keep       4550.59 - 3.36x slower +0.154 ms
xla cpu f32             434.21 - 35.26x slower +2.24 ms
xla gpu f32             398.45 - 38.42x slower +2.44 ms
xla gpu f64             190.27 - 80.46x slower +5.19 ms
xla cpu f64             168.25 - 90.98x slower +5.88 ms
elixir f32                3.22 - 4760.93x slower +310.94 ms
elixir f64                3.11 - 4924.56x slower +321.63 ms
</code></pre>

<p>The takeaway that using 32-bit floating point tensors, keeping the tensors on the GPU memory produces massive performance gains.</p>

<p>Nx represents a new frontier for the Elixir ecosystem.  Adding high performance numerical computation to Elixir allows us to solve more problems on the BEAM and will hopefully make Elixir an attractive choice of language in more domains.  We commend the Nx contributors for such a great initiative.  We&#39;re looking forward to seeing where Nx takes Elixir and the BEAM.</p>

<p><a href="https://twitter.com/ElixirSydney/status/1373203685006712837">https://twitter.com/ElixirSydney/status/1373203685006712837</a></p>

<h2>Elixir Australia</h2>

<p>Elixir Australia is a joint effort by <a href="https://www.meetup.com/elixir-sydney/">Elixir Sydney</a> (sponsored by Alembic) and <a href="https://www.meetup.com/Elixir-Melbourne/">Elixir Melbourne</a> to host monthly online meetups for the Elixir community.  We encourage all Elixir alchemists globally to join either of the meetup groups to keep an eye out for upcoming events (the next scheduled meetup is Wednesday, April 21, 2021 7:00 PM to 9:00 PM GMT+10).  The <a href="https://www.youtube.com/c/ElixirAustralia">YouTube channel</a> can also be subscribed to to keep up to date with videos from the meetups.</p>

<p>Please check out the links and we hope to see you at an Elixir Australia meetup soon!</p>

<h2>Links</h2>

<ul>
<li>The official Elixir Nx code repository: <a href="https://github.com/elixir-nx/nx">https://github.com/elixir-nx/nx</a></li>
<li>Kicking the tyres on Nx talk: <a href="https://www.youtube.com/watch?v=SgSbaGm5nR0">https://www.youtube.com/watch?v=SgSbaGm5nR0</a></li>
<li>Code repo for the code notebook: <a href="https://github.com/team-alembic/elixir_nx_demo">https://github.com/team-alembic/elixir<em>nx</em>demo</a></li>
<li>Elixir Sydney: <a href="https://www.meetup.com/elixir-sydney/">https://www.meetup.com/elixir-sydney/</a></li>
<li>Elixir Melbourne: <a href="https://www.meetup.com/Elixir-Melbourne/">https://www.meetup.com/Elixir-Melbourne/</a></li>
<li>Elixir Australia Youtube channel: <a href="https://www.youtube.com/c/ElixirAustralia">https://www.youtube.com/c/ElixirAustralia</a></li>
</ul>


Numerical performance of Elixir code has received a massive boost with the release of Nx - Numerical Elixir. This is an exciting addition to the Elixir ecosystem, read on to find out what you can do with it!



High performance Numerical Elixir with Nx

<p>This article is part of a series about functional programming with FP-TS. It&#39;s aimed at those who may have heard good things about functional programming but don&#39;t really know where to start approaching the subject. More specifically it&#39;s for JavaScript users who may be aware that their language has something to do with functional programming but not really sure how. Let&#39;s get started!</p>

<h2>What is FP-TS?</h2>

<p>By some definition, one might call JavaScript a functional language due to the fact it has first class functions. However, ask a functional programmer and they&#39;ll most likely balk at such a description as functional programming is much broader in scope.</p>

<p>TypeScript does begin to address these discrepancies by including types. While this is an important start, it really is only a start.</p>

<p><code>fp-ts</code> is an additional layer on top of TypeScript, which leverages existing capabilities and gives us the full power of the functional paradigm. More precisely, it is a TypeScript library which provides additional methods to capture all the concepts a functional programmer would need.</p>

<h2>What are pipelines?</h2>

<p>One of the primary philosophies of functional programming is that you don&#39;t mutate data. Instead the idea is that you have an input which is &quot;piped&quot; through a function. The important point here is no data is mutated; the source of the input is the unaffected by the function and the output is new data. </p>

<p>You can connect these &quot;pipes&quot; together into a longer pipe, much like how actual physical pipes are put together. We could write this as:</p>

<pre><code class="tsx">input -&gt; f1 -&gt; output1 -&gt; f2 -&gt; output2 -&gt; f3
</code></pre>

<p>If you have ever seen any Elixir, F# or Elm code one might see this written with the following syntax:</p>

<pre><code class="elixir">input |&gt; f1 |&gt; f2 |&gt; f3
</code></pre>

<p>If you have used Unix pipes then it&#39;s also the same thing, except with lines of text piped from stdin to stdout / stderr.</p>

<pre><code class="bash">cat file.txt | wc -l
</code></pre>

<h2>Why are pipelines useful?</h2>

<p>So why is this useful? That is a good question. After all, even spaghetti code can technically perform any task we might want. The answer lies in the fact that there is more to writing code than simply getting it to compile. For some the aesthetics of the good code is reward enough, but for others who are more practically minded and aren&#39;t interested in becoming one with the code, there are other incentives. </p>

<p>First of all if we build our programs out of functions without side-effects, then reasoning about your code becomes much simpler. We can be confident that we aren&#39;t going to get nasty side effects from unintentionally mutating data which other code may be using.</p>

<p>Secondly, it allows us to read and write our code as a series of self contained functions which reads more easily; no parsing of complicated &#39;for&#39; loops and &#39;if&#39; statements is required to see what is happening  at the top level of the pipeline. If you need to see the detail, then you can inspect each function in the pipeline in isolation.</p>

<p>If we wanted to try and achieve the same effect in TypeScript where we pass the value of one function to another, the syntax forces us to write something awkward like:</p>

<pre><code class="tsx">output = f3(f2(f1(input)))
</code></pre>

<h2>The Pipe operator in FP-TS</h2>

<p><code>fp-ts</code> gives us the pipe operator to create a pipeline of function:</p>

<pre><code class="tsx">import { pipe } from &#39;fp-ts/lib/function&#39;

const f1 = (x) =&gt; x + 1
const f2 = (x) =&gt; x + 2
const f3 = (x) =&gt; x + 3

pipe(0, f1, f2, f3)  // returns 6
</code></pre>

<p>When we use this in a real program this let&#39;s us reason about high level program flow more easily:</p>

<pre><code class="tsx">pipe(query, fetchFromDatastore, transformResult)
</code></pre>

<p>You can find some more examples in the <a href="https://gcanti.github.io/fp-ts/modules/function.ts.html#pipe">FP-TS pipe documentation</a>.</p>

<h2>The Flow operator in FP-TS</h2>

<p><code>fp-ts</code> gives us another very similar tool called the <code>flow</code> operator. It&#39;s very similar to <code>pipe</code> except that all the arguments are functions and the output it returns is itself a function which one <strong>then</strong> passes in the initial input.</p>

<p>More concretely:</p>

<pre><code class="tsx">import { flow } from &#39;fp-ts/lib/function&#39;

const splitBy = (char: string) =&gt; (s: string) =&gt; s.split(char)
const count = (xs: unknown[]) =&gt; xs.length
const splitBySpace = splitBy(&#39; &#39;)
const countWords = flow(
  splitBySpace,
  count
)

countWords(&#39;a b c&#39;)  // returns 3
</code></pre>

<p>The advantage of <code>flow</code> is that if you want to pass the result of a series of piped functions into another function, you don&#39;t need write an anonymous function.</p>

<p>Instead of:</p>

<pre><code class="tsx">someOtherFunction = (num: number, func: (number) =&gt; number)
someOtherFunction(1, (num) =&gt; pipe(num, f1, f2, f3))
</code></pre>

<p>We can do:</p>

<pre><code class="tsx">someOtherFunction = (num: number, func: (number) =&gt; number)
someOtherFunction(1, flow(f1, f2, f3))
</code></pre>

<p>You can find some more examples in the <a href="https://gcanti.github.io/fp-ts/modules/function.ts.html#flow">FP-TS flow documentation</a>.</p>

<h2>Currying with FP-TS</h2>

<p>What if we want to add functions with multiple arguments to a pipeline? This won&#39;t work because <code>pipe</code> is expecting a single argument function. There is a technique which we can take advantage of to help us.</p>

<p>Currying is the conversion of a function with multiple arguments into a series of single argument functions. For example, a 3 argument function <code>f(x, y, z)</code> becomes <code>((g(x))(y))(z)</code> or <code>g(x)(y)(z)</code>. Each new single argument function returns a new function which again takes the next argument until last function just returns the result.</p>

<p>So instead of:</p>

<pre><code class="tsx">declare const f: (x: A, y: B, z: C) =&gt; D
</code></pre>

<p>We can define a new curried version:</p>

<pre><code class="tsx">declare const curriedF = (x: A) =&gt; (y: B) =&gt; (z: C) =&gt; { return f(x, y, z) }
</code></pre>

<p>So that:</p>

<pre><code class="tsx">const first: (y: B) =&gt; (z: C) =&gt; D = curriedF(a)
const second: (z: C) =&gt; D          = curriedF(a)(b)
const returnValue: D               = curriedF(a)(b)(c)
</code></pre>

<p>This resembles piping but instead of passing the output of a function to the next function, we can think of it as sending a function to a value. In fact if we had a function which takes values and returns a function which takes a curried function and returns the next curried function in the sequence, we could use piping to get this behaviour. As it so happens, <code>fp-ts</code> provides just such a function, <code>ap</code> which is short for &quot;apply&quot;.</p>

<pre><code class="tsx">declare const ap: &lt;A&gt;(arg: A) =&gt; &lt;B&gt;(f: (arg:A) =&gt; B) =&gt; B

ap :: a -&gt; (a -&gt; b) -&gt; b 
</code></pre>

<p>This means we can combine this with piping to get the following:</p>

<pre><code class="tsx">const returnValue = pipe(curriedF, ap(a), ap(b), ap(c))
</code></pre>

<p>What happens here is that we pass the curried version of our function <code>f()</code> along the pipeline passing in values one by one. This might seem a little convoluted In practice we would probably use sequences to do this kind of thing rather than <code>ap</code>, however that&#39;s a topic for another post.</p>

<h2>Conclusion</h2>

<p>We&#39;ve really only just scratched the surface of what <code>fp-ts</code> is about, but hopefully this article has provided some insight into functional programming techniques and the clarity it can bring to your code. In particular the <code>pipe</code> and <code>flow</code> operator gives us a way to express our program in a more linear way.</p>

<p>This is just the beginning however and we shall dive deeper into <code>fp-ts</code> in later articles. So stay tuned!</p>

<h2>References</h2>

<ul>
<li><a href="https://gcanti.github.io/fp-ts/">FP-TS Documentation</a></li>
<li><a href="https://github.com/gcanti/fp-ts">FP-TS GitHub Repo</a></li>
</ul>


FP-TS is a useful library for programming TypeScript with the full power of functional programming. It provides some very handy functional tools from Pipelines to Currying to make our TypeScript programs more elegant and robust.