Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/Goml/Gobrain
Neural Networks written in go
https://github.com/Goml/Gobrain
Last synced: 20 days ago
JSON representation
Neural Networks written in go
- Host: GitHub
- URL: https://github.com/Goml/Gobrain
- Owner: goml
- License: mit
- Created: 2014-04-29T13:32:36.000Z (over 10 years ago)
- Default Branch: master
- Last Pushed: 2020-12-12T12:34:25.000Z (almost 4 years ago)
- Last Synced: 2024-05-22T08:27:30.341Z (6 months ago)
- Language: Go
- Size: 43.9 KB
- Stars: 554
- Watchers: 24
- Forks: 59
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# gobrain
Neural Networks written in go
[](https://godoc.org/github.com/goml/gobrain)
[](https://travis-ci.org/goml/gobrain)
## Getting Started
The version `1.0.0` includes just basic Neural Network functions such as Feed Forward and Elman Recurrent Neural Network.
A simple Feed Forward Neural Network can be constructed and trained as follows:
```go
package main
import (
"github.com/goml/gobrain"
"math/rand"
)
func main() {
// set the random seed to 0
rand.Seed(0)
// create the XOR representation patter to train the network
patterns := [][][]float64{
{{0, 0}, {0}},
{{0, 1}, {1}},
{{1, 0}, {1}},
{{1, 1}, {0}},
}
// instantiate the Feed Forward
ff := &gobrain.FeedForward{}
// initialize the Neural Network;
// the networks structure will contain:
// 2 inputs, 2 hidden nodes and 1 output.
ff.Init(2, 2, 1)
// train the network using the XOR patterns
// the training will run for 1000 epochs
// the learning rate is set to 0.6 and the momentum factor to 0.4
// use true in the last parameter to receive reports about the learning error
ff.Train(patterns, 1000, 0.6, 0.4, true)
}
```
After running this code the network will be trained and ready to be used.
The network can be tested running using the `Test` method, for instance:
```go
ff.Test(patterns)
```
The test operation will print in the console something like:
```
[0 0] -> [0.057503945708445] : [0]
[0 1] -> [0.930100635071210] : [1]
[1 0] -> [0.927809966227284] : [1]
[1 1] -> [0.097408795324620] : [0]
```
Where the first values are the inputs, the values after the arrow `->` are the output values from the network and the values after `:` are the expected outputs.
The method `Update` can be used to predict the output given an input, for example:
```go
inputs := []float64{1, 1}
ff.Update(inputs)
```
the output will be a vector with values ranging from `0` to `1`.
In the example folder there are runnable examples with persistence of the trained network on file.
In example/02 the network is saved on file and in example/03 the network is loaded from file.
To run the example cd in the folder and run
go run main.go
## Recurrent Neural Network
This library implements Elman's Simple Recurrent Network.
To take advantage of this, one can use the `SetContexts` function.
```go
ff.SetContexts(1, nil)
```
In the example above, a single context will be created initialized with `0.5`. It is also possible
to create custom initialized contexts, for instance:
```go
contexts := [][]float64{
{0.5, 0.8, 0.1}
}
```
Note that custom contexts must have the same size of hidden nodes + 1 (bias node),
in the example above the size of hidden nodes is 2, thus the context has 3 values.
## Changelog
* 1.0.0 - Added Feed Forward Neural Network with contexts from Elman RNN