config := []network.LayerConf{
	network.LayerConf{Inputs: 2},
	network.LayerConf{Inputs:3, Activation: activation.LeakyReLU{Leak: 0.01}},
	network.LayerConf{Inputs:1, Activation: activation.LeakyReLU{Leak: 0.01}},
}
net, err := network.NewNetwork(config)
if err != nil {
	log.Fatalln(`can't create network`, err)
}

// Training samples
samples := map[[2]float64][]float64{
	[2]float64{0, 0}: []float64{0},
	[2]float64{0, 1}: []float64{1},
	[2]float64{1, 0}: []float64{1},
	[2]float64{1, 1}: []float64{0},
}

targetMSE := 0.005  // Desired Mean Squared Error
learningRate := 0.1 // Learning rate for the network, larger is faster, smaller is more accurate

var iter int

for iter = 0; iter < 1000; iter++ {
	meanSquaredError := float64(0)

	for input, target := range samples {
		input := input[:]
		output := net.Forward(input)
		error := net.Error(output, target)
		net.Backprop(input, error, learningRate)

		for _, e := range error {
			meanSquaredError += math.Pow(e, 2)
		}
	}

	meanSquaredError /= float64(len(samples))

	if meanSquaredError <= targetMSE {
		break
	}
}

log.Println(`Took`, iter, `iterations to reach target MSE`, targetMSE)

for input, target := range samples {
	log.Println(`Input:`, input, `Target:`, target, `Output:`, net.Forward(input[:])
}

type LayerConf struct {
	Inputs     int
	Activation activation.Activation
}

type Network struct {
}

func NewNetwork(layerConfigs []LayerConf) (*Network, error)

config := []LayerConf{
  LayerConf{Inputs: 2, Activation: nil},
  LayerConf{Inputs: 3, Activation: SigmoidActivation{}},
  LayerConf{Inputs: 1, Activation: SigmoidActivation{}},
}
net := network.NewNetwork(config)

func (n *Network) Backprop(inputs, error []float64, learningRate float64)

input := []float64{0, 1.0, 2.0}
target := []float64{0, 1}
output := net.Forward(input)
error := net.Error(output, target)
net.Backprop(input, error, 0.1) // Perform back propagation with learning rate 0.1

func (n *Network) Error(outputs, targets []float64) []float64

func (n *Network) Forward(inputs []float64) []float64

func (n *Network) Restore(prefix string) error

func (n *Network) Snapshot(prefix string) error