Testing

Mix.install([
  {:nx, "~> 0.2.0"},
  {:exla, "~> 0.2.0"},
  {:axon, "~> 0.1.0-dev", github: "elixir-nx/axon", branch: "main"}
])

Example

require Axon

model =
  Axon.input({nil, 8})
  |> Axon.dense(20, activation: :relu)
  |> Axon.dense(20, activation: :relu)
  # |> Axon.dropout(rate: 0.5)
  |> Axon.dense(2, activation: :softmax)

# |> Axon.dense(2, activation: :sigmoid)

# state_init = model |> Axon.init(compiler: EXLA)

train_data = [
  {Nx.tensor([[0.0, 0, 0, 0, 0, 0, 0, 1.0]]), Nx.tensor([0.0, 1.0])},
  {Nx.tensor([[0.0, 0, 0, 0, 0, 0, 0.0, 0.0]]), Nx.tensor([1.0, 0.0])}
]

trained =
  model
  |> Axon.Loop.trainer(:categorical_cross_entropy, Axon.Optimizers.adamw(0.005))
  |> Axon.Loop.run(train_data, epochs: 100, compiler: EXLA)

Axon.predict(model, trained, %{
  "input_0" => Nx.tensor([[0.0, 0.0, 0, 0, 0, 0, 0.0, 1.0]])
})

Testing

require Axon

model =
  Axon.input({nil, 8})
  |> Axon.dense(128)
  |> Axon.dense(2, activation: :softmax)

state_init = model |> Axon.init(compiler: EXLA)

train_data = [
  {Nx.tensor([[0.0, 0, 0, 0, 0, 0, 0, 1.0]]), Nx.tensor([0.0, 1.0])},
  {Nx.tensor([[0.0, 0, 0, 0, 0, 0, 1.0, 0.0]]), Nx.tensor([1.0, 0.0])}
]

model_state =
  model
  |> Axon.Loop.trainer(:categorical_cross_entropy, Axon.Optimizers.adamw(0.005))
  |> Axon.Loop.run(train_data, epochs: 10, compiler: EXLA)

Axon.predict(model, model_state, %{
  "input_0" => Nx.tensor([[0.0, 0.0, 0, 0, 0, 0, 1.0, 0.0]])
})

:io_lib.format("~8.2.0B", [1])
|> Enum.map(fn d -> if d == ?0, do: 0.0, else: 1.0 end)
|> Nx.tensor()

random_num_oddity = fn ->
  random = Enum.random(0..255)
  odd = if rem(random, 2) == 0, do: true, else: false

  bin_tensor =
    :io_lib.format("~8.2.0B", [random])
    |> Enum.map(fn d -> if d == ?0, do: 0.0, else: 1.0 end)
    |> Nx.tensor()
    |> Nx.reshape({1, 8})

  {bin_tensor, odd}
end

{test_1, test_2} = random_num_oddity.()

random_num_oddity_list = fn ->
  Stream.unfold(0, fn _ ->
    {random_num_oddity.(), 0}
  end)
end

random_num_oddity_list.() |> Enum.take(10)

data_trainning =
  Stream.unfold(0, fn _ ->
    {random_num_oddity.(), 0}
  end)
  |> Stream.map(fn {tn, oddity} ->
    {tn, if(oddity, do: Nx.tensor([0.0, 1.0]), else: Nx.tensor([1.0, 0.0]))}
  end)

# |> Enum.take(10)

require Axon

model =
  Axon.input({nil, 8})
  |> Axon.dense(20, activation: :relu)
  |> Axon.dense(20, activation: :relu)
  # |> Axon.dropout(rate: 0.5)
  |> Axon.dense(2, activation: :softmax)

# |> Axon.dense(2, activation: :sigmoid)

trained =
  model
  |> Axon.Loop.trainer(:categorical_cross_entropy, Axon.Optimizers.adamw(0.005))
  |> Axon.Loop.run(data_trainning |> Enum.take(1_000), epochs: 1, compiler: EXLA)

Axon.predict(
  model,
  trained,
  %{
    "input_0" => Nx.tensor([[0.0, 0.0, 0, 0, 0, 0, 0.0, 1.0]])
  },
  compiler: EXLA
)

Nx.tensor([[0.0, 0, 0, 0, 0, 0, 0, 1.0]])