docs: add a Getting Started Section (#1577)

Co-authored-by: Paulo Valente <16843419+polvalente@users.noreply.github.com>

Author: TomasPegado

exla/README.md

@@ -17,7 +17,7 @@ Then you can add `EXLA` as dependency in your `mix.exs`:
 ```elixir
 def deps do
   [
-    {:exla, "~> 0.5"}
+    {:exla, "~> 0.9"}
   ]
 end
 ```
@@ -26,7 +26,7 @@ If you are using Livebook or IEx, you can instead run:
 
 ```elixir
 Mix.install([
-  {:exla, "~> 0.5"}
+  {:exla, "~> 0.9"}
 ])
 ```
 

exla/guides/rotating-image.livemd

@@ -6,7 +6,7 @@ Mix.install(
     {:nx, github: "elixir-nx/nx", override: true, sparse: "nx"},
     {:req, "~> 0.3.5"},
     {:kino, "~> 0.8.1"},
-    {:exla, "~> 0.5"},
+    {:exla, "~> 0.9"},
     {:stb_image, "~> 0.6"}
   ],
   config: [

nx/README.md

@@ -59,7 +59,7 @@ Then you can add `Nx` as dependency in your `mix.exs`:
 ```elixir
 def deps do
   [
-    {:nx, "~> 0.5"}
+    {:nx, "~> 0.9"}
   ]
 end
 ```
@@ -68,7 +68,7 @@ If you are using Livebook or IEx, you can instead run:
 
 ```elixir
 Mix.install([
-  {:nx, "~> 0.5"}
+  {:nx, "~> 0.9"}
 ])
 ```
 

nx/guides/advanced/aggregation.livemd

@@ -4,7 +4,7 @@
 
 ```elixir
 Mix.install([
-  {:nx, "~> 0.5"}
+  {:nx, "~> 0.9"}
 ])
 ```
 
@@ -93,7 +93,7 @@ m = ~MAT[
 >
 ```
 
-First, we'll compute the full-tensor aggregation. The calculations are developed below. We calculate an "array product" (aka [Hadamard product](https://en.wikipedia.org/wiki/Hadamard_product_(matrices)#:~:text=In%20mathematics%2C%20the%20Hadamard%20product,elements%20i%2C%20j%20of%20the), an element-wise product) of our tensor with the tensor of weights, then sum all the elements and divide by the sum of the weights.
+First, we'll compute the full-tensor aggregation. The calculations are developed below. We calculate an "array product" (aka [Hadamard product](<https://en.wikipedia.org/wiki/Hadamard_product_(matrices)#:~:text=In%20mathematics%2C%20the%20Hadamard%20product,elements%20i%2C%20j%20of%20the>), an element-wise product) of our tensor with the tensor of weights, then sum all the elements and divide by the sum of the weights.
 
 ```elixir
 w = ~MAT[
@@ -689,8 +689,6 @@ $$
 
 <!-- livebook:{"break_markdown":true} -->
 
-
-
 ```elixir
 Nx.argmax(t, axis: :z)
 ```
@@ -785,8 +783,6 @@ $$
 
 <!-- livebook:{"break_markdown":true} -->
 
-
-
 ```elixir
 Nx.argmin(t, axis: 3)
 ```

nx/guides/getting_started/broadcasting.livemd

@@ -0,0 +1,153 @@
+# Broadcasting
+
+The dimensions of tensors in an operator don't always match.
+For example, you might want to subtract a `1` from every
+element of a `{2, 2}`-shaped tensor, like this:
+
+$$
+\begin{bmatrix}
+  1 & 2 \\\\
+  3 & 4
+\end{bmatrix} - 1 =
+\begin{bmatrix}
+  0 & 1 \\\\
+  2 & 3
+\end{bmatrix}
+$$
+
+Mathematically, this is the same as:
+
+$$
+\begin{bmatrix}
+  1 & 2 \\\\
+  3 & 4
+\end{bmatrix} -
+\begin{bmatrix}
+  1 & 1 \\\\
+  1 & 1
+\end{bmatrix} =
+\begin{bmatrix}
+  0 & 1 \\\\
+  2 & 3
+\end{bmatrix}
+$$
+
+This means we need a way to convert `1` to a `{2, 2}`-shaped tensor.
+`Nx.broadcast/2` solves that problem. This function takes
+a tensor or a scalar and a shape.
+
+```elixir
+Mix.install([
+  {:nx, "~> 0.9"}
+])
+
+
+Nx.broadcast(1, {2, 2})
+```
+
+This call takes the scalar `1` and translates it
+to a compatible shape by copying it. Sometimes, it's easier
+to provide a tensor as the second argument, and let `broadcast/2`
+extract its shape:
+
+```elixir
+tensor = Nx.tensor([[1, 2], [3, 4]])
+Nx.broadcast(1, tensor)
+```
+
+The code broadcasts `1` to the shape of `tensor`. In many operators
+and functions, the broadcast happens automatically:
+
+```elixir
+Nx.subtract(tensor, 1)
+```
+
+This result is possible because Nx broadcasts _both tensors_
+in `subtract/2` to compatible shapes. That means you can provide
+scalar values as either argument:
+
+```elixir
+Nx.subtract(10, tensor)
+```
+
+Or subtract a row or column. Mathematically, it would look like this:
+
+$$
+\begin{bmatrix}
+  1 & 2 \\\\
+  3 & 4
+\end{bmatrix} -
+\begin{bmatrix}
+  1 & 2
+\end{bmatrix} =
+\begin{bmatrix}
+  0 & 0 \\\\
+  2 & 2
+\end{bmatrix}
+$$
+
+which is the same as this:
+
+$$
+\begin{bmatrix}
+  1 & 2 \\\\
+  3 & 4
+\end{bmatrix} -
+\begin{bmatrix}
+  1 & 2 \\\\
+  1 & 2
+\end{bmatrix} =
+\begin{bmatrix}
+  0 & 0 \\\\
+  2 & 2
+\end{bmatrix}
+$$
+
+This rewrite happens in Nx as well, through a broadcast operation. We want to
+broadcast the tensor `[1, 2]` to match the `{2, 2}` shape:
+
+```elixir
+Nx.broadcast(Nx.tensor([1, 2]), {2, 2})
+```
+
+The `subtract` function in `Nx` takes care of that broadcast
+implicitly, as discussed above:
+
+```elixir
+Nx.subtract(tensor, Nx.tensor([1, 2]))
+```
+
+The broadcast worked as expected, copying the `[1, 2]` row
+enough times to fill a `{2, 2}`-shaped tensor. A tensor with a
+dimension of `1` will broadcast to fill the tensor:
+
+```elixir
+[[1], [2]] |> Nx.tensor() |> Nx.broadcast({1, 2, 2})
+```
+
+```elixir
+[[[1, 2, 3]]]
+|> Nx.tensor()
+|> Nx.broadcast({4, 2, 3})
+```
+
+Both of these examples copy parts of the tensor enough
+times to fill out the broadcast shape. You can check out the
+Nx broadcasting documentation for more details:
+
+<!-- livebook:{"disable_formatting":true} -->
+
+```elixir
+h Nx.broadcast
+```
+
+Much of the time, you won't have to broadcast yourself. Many of
+the functions and operators Nx supports will do so automatically.
+
+We can use tensor-aware operators via various `Nx` functions and
+many of them implicitly broadcast tensors.
+
+Throughout this section, we have been invoking `Nx.subtract/2` and
+our code would be more expressive if we could use its equivalent
+mathematical operator. Fortunately, Nx provides a way. Next, we'll
+dive into numerical definitions using `defn`.

nx/guides/getting_started/installation.md

@@ -0,0 +1,150 @@
+# Installation
+
+The only prerequisite for installing Nx is Elixir itself. If you don't have Elixir installed
+in your machine you can visit this [installation page](https://elixir-lang.org/install.html).
+
+There are several ways to install Nx (Numerical Elixir), depending on your project type and needs.
+
+## Using Mix in a standardElixir Project
+
+If you are working inside a Mix project, the recommended way to install Nx is by adding it to your mix.exs dependencies:
+
+1. Open mix.exs and modify the deps function:
+
+```elixir
+defp deps do
+  [
+    {:nx, "~> 0.9"}  # Install the latest stable version
+  ]
+end
+```
+
+2. Fetch the dependencies, run on the terminal:
+
+```sh
+mix deps.get
+```
+
+## Installing Nx from GitHub (Latest Development Version)
+
+If you need the latest, unreleased features, install Nx directly from the GitHub repository.
+
+1. Modify `mix.exs`:
+
+```elixir
+defp deps do
+  [
+    {:nx, github: "elixir-nx/nx", branch: "main", sparse: "nx"}
+  ]
+end
+```
+
+2. Fetch dependencies:
+
+```sh
+mix deps.get
+```
+
+## Installing Nx in a Standalone Script (Without a Mix Project)
+
+If you don’t have a Mix project and just want to run a standalone script, use Mix.install/1 to dynamically fetch and install Nx.
+
+```elixir
+Mix.install([:nx])
+
+require Nx
+
+tensor = Nx.tensor([1, 2, 3])
+IO.inspect(tensor)
+```
+
+Run the script with:
+
+```sh
+elixir my_script.exs
+```
+
+Best for: Quick experiments, small scripts, or one-off computations.
+
+## Installing the Latest Nx from GitHub in a Standalone Script
+
+To use the latest development version in a script (without a Mix project):
+
+```elixir
+Mix.install([
+  {:nx, github: "elixir-nx/nx", branch: "main", sparse: "nx"}
+])
+
+require Nx
+
+tensor = Nx.tensor([1, 2, 3])
+IO.inspect(tensor)
+```
+
+Run:
+
+```sh
+elixir my_script.exs
+```
+
+Best for: Trying new features from Nx without creating a full project.
+
+## Installing Nx with EXLA for GPU Acceleration
+
+To enable GPU/TPU acceleration with Google’s XLA backend, install Nx along with EXLA:
+
+1. Modify mix.exs:
+
+```elixir
+defp deps do
+  [
+    {:nx, "~> 0.9"},
+    {:exla, "~> 0.9"}  # EXLA (Google XLA Backend)
+  ]
+end
+```
+
+2. Fetch dependencies:
+
+```sh
+mix deps.get
+```
+
+3. Run with EXLA enabled:
+
+```elixir
+Nx.default_backend(EXLA.Backend)
+Nx.Defn.default_options(compiler: EXLA)
+```
+
+Best for: Running Nx on GPUs or TPUs using Google’s XLA compiler.
+
+## Installing Nx with Torchx for PyTorch Acceleration
+
+To run Nx operations on PyTorch’s backend (LibTorch):
+
+1. Modify mix.exs:
+
+```elixir
+defp deps do
+  [
+    {:nx, "~> 0.9"},
+    {:torchx, "~> 0.9"}  # PyTorch Backend
+  ]
+end
+
+```
+
+2. Fetch dependencies:
+
+```sh
+mix deps.get
+```
+
+3. Run with Torchx enabled:
+
+```elixir
+Nx.default_backend(Torchx.Backend)
+```
+
+Best for: Deep learning applications with PyTorch acceleration.