-module(gleam_synapses@model@net_elems@neuron@neuron).
-compile(no_auto_import).

-export([init/3, output/2, back_propagated/4, generator/1]).
-export_type([neuron/0]).

-type neuron() :: {neuron,
                   gleam_synapses@model@net_elems@activation@activation:activation(),
                   gleam_zlists@interop:z_list(float())}.

-spec init(
    integer(),
    gleam_synapses@model@net_elems@activation@activation:activation(),
    fun(() -> float())
) -> neuron().
init(Input_size, Activation_f, Weight_init_f) ->
    Weights = begin
        _pipe = gleam_zlists:indices(),
        _pipe@1 = gleam_zlists:take(_pipe, Input_size + 1),
        gleam_zlists:map(_pipe@1, fun(_) -> Weight_init_f() end)
    end,
    {neuron, Activation_f, Weights}.

-spec output(neuron(), gleam_zlists@interop:z_list(float())) -> float().
output(Neuron, Input_val) ->
    Activation_input = begin
        _pipe = Input_val,
        _pipe@1 = gleam_zlists:cons(_pipe, 1.0),
        gleam_synapses@model@mathematics:dot_product(
            _pipe@1,
            erlang:element(3, Neuron)
        )
    end,
    (gleam_synapses@model@net_elems@activation@activation:f(
        erlang:element(2, Neuron)
    ))(Activation_input).

-spec back_propagated(
    neuron(),
    float(),
    gleam_zlists@interop:z_list(float()),
    {float(), float()}
) -> {gleam_zlists@interop:z_list(float()), neuron()}.
back_propagated(Neuron, Learning_rate, Input_val, Output_with_error) ->
    {Output_val, Error} = Output_with_error,
    Output_inverse = (gleam_synapses@model@net_elems@activation@activation:inverse(
        erlang:element(2, Neuron)
    ))(Output_val),
    Common = Error * (gleam_synapses@model@net_elems@activation@activation:deriv(
        erlang:element(2, Neuron)
    ))(Output_inverse),
    In_errors = gleam_zlists:map(Input_val, fun(X) -> X * Common end),
    New_weights = begin
        _pipe = Input_val,
        _pipe@1 = gleam_zlists:cons(_pipe, 1.0),
        _pipe@2 = gleam_zlists:zip(_pipe@1, erlang:element(3, Neuron)),
        gleam_zlists:map(
            _pipe@2,
            fun(X@1) ->
                {A, B} = X@1,
                B
                - ((Learning_rate
                * Common)
                * A)
            end
        )
    end,
    New_neuron = {neuron, erlang:element(2, Neuron), New_weights},
    {In_errors, New_neuron}.

-spec generator(integer()) -> minigen:generator(neuron()).
generator(Input_size) ->
    Weights_generator = begin
        _pipe = minigen:float(),
        _pipe@1 = minigen:map(_pipe, fun(X) -> 1.0 - (2.0 * X) end),
        _pipe@2 = minigen:list(_pipe@1, Input_size + 1),
        minigen:map(_pipe@2, fun gleam_zlists:of_list/1)
    end,
    minigen:map2(
        gleam_synapses@model@net_elems@activation@activation:generator(),
        Weights_generator,
        fun(A, B) -> {neuron, A, B} end
    ).