Hi,

I’m reading the book Programming Machine Learning and trying to translate examples in Elixir using Nx.

Here is the code I exported from my Livebook.

# Linear Regression

```
Mix.install([
{:nx, "~> 0.4.2"},
{:axon, "~> 0.4.1"},
{:explorer, "~> 0.5.0"},
{:kino, "~> 0.8.0"},
{:vega_lite, "~> 0.1.6"},
{:kino_vega_lite, "~> 0.1.7"}
])
```

## Data

```
csv = """
Reservations,Pizzas
13,33
2,16
14,32
23,51
13,27
1,16
18,34
10,17
26,29
3,15
3,15
21,32
7,22
22,37
2,13
27,44
6,16
10,21
18,37
15,30
9,26
26,34
8,23
15,39
10,27
21,37
5,17
6,18
13,25
13,23
"""
{:ok, data} =
csv
|> Explorer.DataFrame.load_csv()
reserv = data["Reservations"]
pizzas = data["Pizzas"]
```

Let’s plot the actual values and our first attempt to model.

```
weight_text = Kino.Input.text("Weight", default: "1")
```

```
alias VegaLite, as: Vl
{weight, _} = Float.parse(Kino.Input.read(weight_text))
model = Explorer.DataFrame.new(iter: 1..Explorer.Series.max(reserv))
chart1 =
Vl.new()
|> Vl.data_from_values(data, only: ["Reservations", "Pizzas"])
|> Vl.mark(:point)
|> Vl.encode_field(:x, "Reservations", type: :quantitative)
|> Vl.encode_field(:y, "Pizzas", type: :quantitative)
chart2 =
Vl.new()
|> Vl.data_from_values(model, only: ["iter", "weights"])
|> Vl.transform(calculate: "datum.iter * #{weight}", as: "weights")
|> Vl.mark(:line)
|> Vl.encode_field(:x, "iter", type: :quantitative)
|> Vl.encode_field(:y, "weights", type: :quantitative)
combined =
Vl.new(width: 400, height: 300)
|> Vl.layers([chart1, chart2])
```

This is how VegaLite creates a linear regression.

```
Vl.new(width: 400, height: 300)
|> Vl.data_from_values(
reservations: Explorer.Series.to_list(reserv),
pizzas: Explorer.Series.to_list(pizzas)
)
|> Vl.layers([
Vl.new()
|> Vl.mark(:point, filled: true)
|> Vl.encode_field(:x, "reservations", type: :quantitative)
|> Vl.encode_field(:y, "pizzas", type: :quantitative),
Vl.new()
|> Vl.mark(:line, color: :firebrick)
|> Vl.transform(regression: "pizzas", on: "reservations")
|> Vl.encode_field(:x, "reservations", type: :quantitative)
|> Vl.encode_field(:y, "pizzas", type: :quantitative)
])
```

## Predict and Loss

```
defmodule MachineLearning do
def predict(x, w, b) do
x
|> Nx.multiply(w)
|> Nx.add(b)
end
def loss(x, y, w, b) do
# basically mean squared error
predict(x, w, b)
|> Nx.subtract(y)
|> Nx.power(2)
|> Nx.mean()
end
def train(x, y, iter, lr) do
# initialize weights and biases to 0
Enum.reduce_while(1..iter, {0.0, 0.0}, fn i, {w, b} ->
current_loss = loss(x, y, w, b)
IO.puts("Iter ##{i} => Loss: #{inspect(current_loss)}")
cond do
loss(x, y, w + lr, b) < current_loss ->
{:cont, {w + lr, b}}
loss(x, y, w - lr, b) < current_loss ->
{:cont, {w - lr, b}}
loss(x, y, w, b + lr) < current_loss ->
{:cont, {w, b + lr}}
loss(x, y, w, b - lr) < current_loss ->
{:cont, {w, b - lr}}
true ->
{:halt, {w, b}}
end
end)
end
end
reserv_t = Nx.tensor(Explorer.Series.to_list(reserv))
pizzas_t = Nx.tensor(Explorer.Series.to_list(pizzas))
MachineLearning.train(reserv_t, pizzas_t, 50, 0.1)
```

I could not properly make it work on the training part, it always stops the training after a few iterations. Where do you think I get it wrong?