Gophercon

Author: andersondalmina

.gitignore

@@ -1,2 +1,4 @@
-flappy-bird-neural-network
 .vscode
+flappy-bird
+neuraldump_ia.json
+neuraldump_iahard.json

components/bird.go

@@ -44,7 +44,7 @@ func NewBird(x float64, sprite *pixel.Sprite) *Bird {
 		Points:         0,
 		Dead:           false,
 		Ghost:          false,
-		GhostCountdown: ghostCountdown,
+		GhostCountdown: 0,
 	}
 }
 
@@ -101,7 +101,7 @@ func (b *Bird) UseGhost() {
 		b.GhostCountdown = ghostCountdown
 		b.Ghost = true
 
-		time.AfterFunc(2*time.Second, func() {
+		time.AfterFunc(3*time.Second, func() {
 			b.Ghost = false
 		})
 	}

components/sprites.go

@@ -2,7 +2,9 @@ package components
 
 import (
 	"image"
+	"log"
 	"os"
+	"path/filepath"
 
 	"github.com/faiface/pixel"
 )
@@ -12,74 +14,81 @@ var Sprites = loadSprites()
 
 // LoadSprites load all imagens and return a sprite to each one
 func loadSprites() map[string]*pixel.Sprite {
+	dir, err := os.Executable()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	dir = filepath.Dir(dir)
+
 	result := make(map[string]*pixel.Sprite)
-	picBackground, err := loadPicture("./assets/background.png")
+	picBackground, err := loadPicture(dir + "/assets/background.png")
 	if err != nil {
 		panic(err)
 	}
 	result["background"] = pixel.NewSprite(picBackground, picBackground.Bounds())
 
-	picFloor, err := loadPicture("./assets/floor.png")
+	picFloor, err := loadPicture(dir + "/assets/floor.png")
 	if err != nil {
 		panic(err)
 	}
 	result["floor"] = pixel.NewSprite(picFloor, picFloor.Bounds())
 
-	picBird, err := loadPicture("./assets/bird10.png")
+	picBird, err := loadPicture(dir + "/assets/bird10.png")
 	if err != nil {
 		panic(err)
 	}
 	result["bird10"] = pixel.NewSprite(picBird, picBird.Bounds())
 
-	picBird, err = loadPicture("./assets/bird11.png")
+	picBird, err = loadPicture(dir + "/assets/bird11.png")
 	if err != nil {
 		panic(err)
 	}
 	result["bird11"] = pixel.NewSprite(picBird, picBird.Bounds())
 
-	picBird, err = loadPicture("./assets/bird12.png")
+	picBird, err = loadPicture(dir + "/assets/bird12.png")
 	if err != nil {
 		panic(err)
 	}
 	result["bird12"] = pixel.NewSprite(picBird, picBird.Bounds())
 
-	picBird, err = loadPicture("./assets/bird13.png")
+	picBird, err = loadPicture(dir + "/assets/bird13.png")
 	if err != nil {
 		panic(err)
 	}
 	result["bird13"] = pixel.NewSprite(picBird, picBird.Bounds())
 
-	picBird, err = loadPicture("./assets/bird14.png")
+	picBird, err = loadPicture(dir + "/assets/bird14.png")
 	if err != nil {
 		panic(err)
 	}
 	result["bird14"] = pixel.NewSprite(picBird, picBird.Bounds())
 
-	picBird, err = loadPicture("./assets/bird15.png")
+	picBird, err = loadPicture(dir + "/assets/bird15.png")
 	if err != nil {
 		panic(err)
 	}
 	result["bird15"] = pixel.NewSprite(picBird, picBird.Bounds())
 
-	picBird, err = loadPicture("./assets/bird16.png")
+	picBird, err = loadPicture(dir + "/assets/bird16.png")
 	if err != nil {
 		panic(err)
 	}
 	result["bird16"] = pixel.NewSprite(picBird, picBird.Bounds())
 
-	picUp, err := loadPicture("./assets/pipeup.png")
+	picUp, err := loadPicture(dir + "/assets/pipeup.png")
 	if err != nil {
 		panic(err)
 	}
 	result["pipeUp"] = pixel.NewSprite(picUp, picUp.Bounds())
 
-	picDown, err := loadPicture("./assets/pipedown.png")
+	picDown, err := loadPicture(dir + "/assets/pipedown.png")
 	if err != nil {
 		panic(err)
 	}
 	result["pipeDown"] = pixel.NewSprite(picDown, picDown.Bounds())
 
-	pic, err := loadPicture("./assets/wall.png")
+	pic, err := loadPicture(dir + "/assets/wall.png")
 	if err != nil {
 		panic(err)
 	}

components/text.go

@@ -4,7 +4,9 @@ import (
 	"fmt"
 	"image/color"
 	"io/ioutil"
+	"log"
 	"os"
+	"path/filepath"
 
 	"github.com/faiface/pixel"
 	"github.com/faiface/pixel/pixelgl"
@@ -29,7 +31,14 @@ func CreateTextLine(txt string, color color.RGBA) Text {
 
 // WriteText draw the text on the window
 func WriteText(txt []Text, color color.RGBA, win *pixelgl.Window, mat pixel.Matrix) {
-	face, err := loadTTF("./assets/font.ttf", 14)
+	dir, err := os.Executable()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	dir = filepath.Dir(dir)
+
+	face, err := loadTTF(dir+"/assets/font.ttf", 14)
 	if err != nil {
 		panic(err)
 	}

components/window.go

@@ -28,15 +28,6 @@ func CreateWindow(t string) (*pixelgl.Window, error) {
 	return pixelgl.NewWindow(wConfig)
 }
 
-// Max returns the larger of x or y.
-func Max(x, y float64) float64 {
-	if x < y {
-		return y
-	}
-
-	return x
-}
-
 // Min returns the larger of x or y.
 func Min(x, y float64) float64 {
 	if x > y {

flappy-bird-neural-network

@@ -1,6 +1,6 @@
 module github.com/andersondalmina/flappy-bird-neural-network
 
-go 1.12
+go 1.13
 
 require (
 	github.com/faiface/glhf v0.0.0-20181018222622-82a6317ac380 // indirect

flappy_bird

@@ -0,0 +1,36 @@
+# Go parameters
+GOCMD=go
+GOBUILD=$(GOCMD) build
+GOCLEAN=$(GOCMD) clean
+GOTEST=$(GOCMD) test
+GOGET=$(GOCMD) get
+BINARY_NAME=flappy_bird
+BINARY_UNIX=$(BINARY_NAME)_unix
+BINARY_MACOS=$(BINARY_NAME)_macos
+
+all: test build
+
+build:
+	$(GOGET)
+	$(GOBUILD) -o $(BINARY_NAME) -v
+
+test:
+	$(GOTEST) -v ./...
+
+clean:
+	$(GOCLEAN)
+	rm -f $(BINARY_NAME)
+	rm -f $(BINARY_UNIX)
+	rm -f $(BINARY_MACOS)
+
+run:
+	$(GOBUILD) -o $(BINARY_NAME) -v ./...
+	./$(BINARY_NAME)
+
+
+# Cross compilation
+build-linux:
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 $(GOBUILD) -o $(BINARY_UNIX) -v
+
+build-macos:
+	CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 $(GOBUILD) -o $(BINARY_MACOS) -v

go.mod

@@ -27,8 +27,8 @@ func (l *Layer) Neurons() []*Neuron {
 	return l.neurons
 }
 
-// Run predicts all neurons
-func (l *Layer) Run(inputs []float64) []float64 {
+// Predict all neurons of the layer
+func (l *Layer) Predict(inputs []float64) []float64 {
 	r := make([]float64, len(l.neurons))
 	for i, n := range l.neurons {
 		r[i] = n.Predict(inputs)

makefile

@@ -35,10 +35,16 @@ func NewNeuralNetwork(c Config) *NeuralNetwork {
 // Predict computes a forward pass and returns a prediction
 func (n *NeuralNetwork) Predict(input []float64) []float64 {
 	for _, l := range n.layers {
-		input = l.Run(input)
+		input = l.Predict(input)
 	}
 
-	return input
+	result := make([]float64, len(input))
+
+	for i, value := range input {
+		result[i] = relu(value)
+	}
+
+	return result
 }
 
 // Weights return the weights of all neurons of the network
@@ -55,11 +61,13 @@ func (n *NeuralNetwork) Weights() [][][]float64 {
 	return res
 }
 
-// SetWeights set the weight of each neuron
-func (n *NeuralNetwork) SetWeights(w [][][]float64) {
+// UpdateWeights set the weight of each neuron
+func (n *NeuralNetwork) UpdateWeights(w [][][]float64) {
+	weights := ajustWeight(w)
+
 	for il, l := range n.layers {
 		for in, ne := range l.neurons {
-			ne.SetWeights(w[il][in])
+			ne.SetWeights(weights[il][in])
 		}
 	}
 }
@@ -84,25 +92,37 @@ func (n *NeuralNetwork) ImportDump(filepath string) error {
 		log.Fatalln(err)
 	}
 
-	n.SetWeights(data)
+	n.UpdateWeights(data)
 
 	return nil
 }
 
-// AjustWeight make changes in weights
-func AjustWeight(bestWeights [][][]float64) [][][]float64 {
-	var w [][][]float64
+// ajustWeight make changes in weights
+func ajustWeight(bestWeights [][][]float64) [][][]float64 {
+	w := make([][][]float64, len(bestWeights))
+
+	for i := range bestWeights {
+		w[i] = make([][]float64, len(bestWeights[i]))
 
-	for z := range bestWeights {
-		for zz := range bestWeights[z] {
-			for zzz := range bestWeights[z][zz] {
-				w[z][zz][zzz] = bestWeights[z][zz][zzz]
+		for ii := range bestWeights[i] {
+			w[i][ii] = make([]float64, len(bestWeights[i][ii]))
+
+			for iii := range bestWeights[i][ii] {
+				w[i][ii][iii] = bestWeights[i][ii][iii]
 				if rand.Intn(4) == 0 {
-					w[z][zz][zzz] += (rand.Float64()*2 - 1) * 100
+					w[i][ii][iii] += (rand.Float64()*2 - 1) * 100
 				}
 			}
 		}
 	}
 
 	return w
 }
+
+func relu(x float64) float64 {
+	if x <= 0 {
+		return 0
+	}
+
+	return 1
+}

neuralnetwork/layer.go

@@ -0,0 +1,17 @@
+package neuralnetwork
+
+import (
+	"math/rand"
+	"testing"
+	"time"
+)
+
+func TestNewNeuron(t *testing.T) {
+	src := rand.NewSource(time.Now().UTC().UnixNano())
+
+	n := NewNeuron(3, src)
+
+	if n.Inputs() != 3 {
+		t.Errorf("Inputs Len must be %d, has %d", 3, n.Inputs())
+	}
+}

neuralnetwork/neuralnetwork.go

@@ -4,7 +4,9 @@ import (
 	"bytes"
 	"encoding/json"
 	"io"
+	"log"
 	"os"
+	"path/filepath"
 	"sync"
 )
 
@@ -23,12 +25,28 @@ func unmarshal(r io.Reader, v interface{}) error {
 	return json.NewDecoder(r).Decode(v)
 }
 
+// GetRootDir return root directory path
+func GetRootDir() string {
+	dir, err := os.Executable()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return filepath.Dir(dir)
+}
+
+// CheckFileExists verify if file exists
+func CheckFileExists(path string) error {
+	_, err := os.Stat(GetRootDir() + "/" + path)
+	return err
+}
+
 // Save saves to the file
 func Save(path string, v interface{}) error {
 	lock.Lock()
 	defer lock.Unlock()
 
-	f, err := os.Create(path)
+	f, err := os.Create(GetRootDir() + "/" + path)
 	if err != nil {
 		return err
 	}
@@ -49,7 +67,7 @@ func Load(path string, v interface{}) error {
 	lock.Lock()
 	defer lock.Unlock()
 
-	f, err := os.Open(path)
+	f, err := os.Open(GetRootDir() + "/" + path)
 	if err != nil {
 		return err
 	}

neuralnetwork/neuron_test.go

@@ -22,6 +22,10 @@ func CreateGameOverScene(p int64) Scene {
 	return &s
 }
 
+func (s *gameOverScene) Load() Scene {
+	return s
+}
+
 func (s *gameOverScene) Run(win *pixelgl.Window) Scene {
 	win.Clear(colornames.Skyblue)
 
@@ -40,7 +44,7 @@ func (s *gameOverScene) Run(win *pixelgl.Window) Scene {
 	components.WriteText(text, colorMenu, win, mat)
 
 	if win.JustPressed(pixelgl.KeyEnter) {
-		return CreateMenuScene()
+		return CreateMenuScene().Load()
 	}
 
 	return s

persist/persist.go

@@ -13,25 +13,33 @@ import (
 )
 
 // IndNumber number of individuals of a population
-const IndNumber = 100
+const IndNumber = 200
 
 var bestWeights = make([][][]float64, 10)
 var weights = make([][][]float64, 10)
 var bestPoints int64
+var datafile string
 
 type ia struct {
-	pop       *components.Population
-	obstacles []components.Obstacle
+	generation int64
+	pop        *components.Population
+	obstacles  []components.Obstacle
 }
 
 // CreateIAScene create a scene when a machine plays
 func CreateIAScene(gn int64) Scene {
+	return &ia{
+		generation: gn,
+	}
+}
+
+func (s *ia) Load() Scene {
+	datafile = "data/neuraldump_ia.json"
+
 	rand.Seed(time.Now().UTC().UnixNano())
 
-	s := ia{
-		pop:       components.CreateNewPopulation(gn),
-		obstacles: make([]components.Obstacle, 4),
-	}
+	s.pop = components.CreateNewPopulation(s.generation)
+	s.obstacles = make([]components.Obstacle, 4)
 
 	var n int64
 	var t string
@@ -41,24 +49,12 @@ func CreateIAScene(gn int64) Scene {
 		t = strconv.FormatInt(n, 10)
 		neural := neuralnetwork.NewNeuralNetwork(neuralnetwork.Config{
 			Inputs: 2,
-			Layers: []int64{3, 1},
+			Layers: []int64{10, 20, 1},
 		})
 		ind = components.NewIndividual(components.NewBird(components.BirdX-rand.Float64()*200, components.Sprites["bird1"+t]), neural)
 
-		if gn > 1 {
-			weights = ind.Neural().Weights()
-			for z := range bestWeights {
-				for zz := range bestWeights[z] {
-					for zzz := range bestWeights[z][zz] {
-						weights[z][zz][zzz] = bestWeights[z][zz][zzz]
-						if rand.Intn(4) == 0 {
-							weights[z][zz][zzz] += (rand.Float64()*2 - 1) * 100
-						}
-					}
-				}
-			}
-
-			ind.Neural().SetWeights(weights)
+		if s.generation > 1 {
+			ind.Neural().UpdateWeights(bestWeights)
 		}
 
 		s.pop.AddIndividual(ind)
@@ -68,7 +64,7 @@ func CreateIAScene(gn int64) Scene {
 		s.obstacles[i] = components.NewPipe(components.WindowWidth+320*float64(i), (components.WindowHeight-components.PipeHeight*2)-rand.Float64()*10*components.PipeHeight)
 	}
 
-	return &s
+	return s
 }
 
 func (s *ia) Run(win *pixelgl.Window) Scene {
@@ -104,7 +100,8 @@ func (s *ia) Run(win *pixelgl.Window) Scene {
 
 		ind.SetInputs(bInputs)
 
-		if Max(ind.Neural().Predict(bInputs)[0], 0) > 0 {
+		result := ind.Neural().Predict(bInputs)
+		if result[0] > 0 {
 			bird.Jump()
 		}
 
@@ -135,7 +132,7 @@ func (s *ia) Run(win *pixelgl.Window) Scene {
 			bestPoints = best.Bird().Points
 		}
 
-		return CreateIAScene(s.pop.Generation() + 1)
+		return CreateIAScene(s.pop.Generation() + 1).Load()
 	}
 
 	return s
@@ -225,12 +222,3 @@ func CheckIndividualsDead(pop []*components.Individual) bool {
 
 	return true
 }
-
-// Max returns the larger of x or y.
-func Max(x, y float64) float64 {
-	if x < y {
-		return y
-	}
-
-	return x
-}

scenes/game_over.go

@@ -2,33 +2,49 @@ package scenes
 
 import (
 	"math/rand"
-	"os"
 	"strconv"
 	"time"
 
 	"github.com/andersondalmina/flappy-bird-neural-network/components"
 	"github.com/andersondalmina/flappy-bird-neural-network/neuralnetwork"
+	"github.com/andersondalmina/flappy-bird-neural-network/persist"
 	"github.com/faiface/pixel"
 	"github.com/faiface/pixel/pixelgl"
 	"golang.org/x/image/colornames"
 )
 
-const datafile = "neuraldump_iahard.json"
-
 type iaHard struct {
-	pop       *components.Population
-	obstacles []components.Obstacle
+	generation int64
+	pop        *components.Population
+	obstacles  []components.Obstacle
 }
 
 // CreateIAHardScene create a scene when a machine plays
 func CreateIAHardScene(gn int64) Scene {
+	return &iaHard{
+		generation: gn,
+	}
+}
+
+func (s *iaHard) Load() Scene {
+	datafile = "neuraldump_iahard.json"
+
+	var data [][][]float64
+	var err error
+
 	rand.Seed(time.Now().UTC().UnixNano())
 
 	resetWallTime()
 
-	s := iaHard{
-		pop:       components.CreateNewPopulation(gn),
-		obstacles: make([]components.Obstacle, 4),
+	s.pop = components.CreateNewPopulation(s.generation)
+	s.obstacles = make([]components.Obstacle, 4)
+
+	err = persist.CheckFileExists(datafile)
+	if err == nil {
+		err = persist.Load(datafile, &data)
+		if err != nil {
+			panic(err)
+		}
 	}
 
 	var n int64
@@ -38,27 +54,28 @@ func CreateIAHardScene(gn int64) Scene {
 		n = rand.Int63n(4) + 1
 		t = strconv.FormatInt(n, 10)
 		neural := neuralnetwork.NewNeuralNetwork(neuralnetwork.Config{
-			Inputs: 4,
-			Layers: []int64{4, 20, 2},
+			Inputs: 3,
+			Layers: []int64{10, 20, 1},
 		})
 		ind = components.NewIndividual(components.NewBird(components.BirdX-rand.Float64()*200, components.Sprites["bird1"+t]), neural)
 
-		_, err := os.Stat(datafile)
-		if gn == 1 && err == nil {
-			ind.Neural().ImportDump(datafile)
+		if s.generation == 1 {
+			ind.Neural().UpdateWeights(data)
 
-		} else if gn > 1 {
-			ind.Neural().SetWeights(neuralnetwork.AjustWeight(ind.Neural().Weights()))
+		} else if s.generation > 1 {
+			ind.Neural().UpdateWeights(ind.Neural().Weights())
 		}
 
 		s.pop.AddIndividual(ind)
 	}
 
-	for i := 0; i < 4; i++ {
+	for i := 0; i < 3; i++ {
 		s.obstacles[i] = components.NewPipe(components.WindowWidth+320*float64(i), (components.WindowHeight-components.PipeHeight*2)-rand.Float64()*10*components.PipeHeight)
 	}
 
-	return &s
+	s.obstacles[3] = components.NewWall(components.WindowWidth + 320*3)
+
+	return s
 }
 
 func (s *iaHard) Run(win *pixelgl.Window) Scene {
@@ -90,20 +107,21 @@ func (s *iaHard) Run(win *pixelgl.Window) Scene {
 			continue
 		}
 
-		bInputs = make([]float64, 4)
+		bInputs = make([]float64, 3)
 		np = s.getBirdNextObstacle(bird)
 		bInputs[0] = np.GetX() - bird.X
 		bInputs[1] = np.GetY() - components.PipeHeight - bird.Y
 		bInputs[2] = np.GetType()
-		bInputs[3] = float64(bird.GhostCountdown)
 
 		ind.SetInputs(bInputs)
 
 		result = ind.Neural().Predict(bInputs)
 
 		if result[0] > 0 {
 			bird.Jump()
-		} else if result[1] > 0 {
+		}
+
+		if result[1] > 0 {
 			bird.UseGhost()
 		}
 
@@ -130,17 +148,15 @@ func (s *iaHard) Run(win *pixelgl.Window) Scene {
 			}
 		}
 
-		// if best.Bird().Points > bestPoints {
 		bestWeights = best.Neural().Weights()
 		bestPoints = best.Bird().Points
-		// }
 
 		err := best.Neural().Dump(datafile)
 		if err != nil {
 			panic(err)
 		}
 
-		return CreateIAHardScene(s.pop.Generation() + 1)
+		return CreateIAHardScene(s.pop.Generation() + 1).Load()
 	}
 
 	return s

scenes/ia.go

@@ -49,6 +49,10 @@ func CreateMenuScene() Scene {
 	}
 }
 
+func (s *menu) Load() Scene {
+	return s
+}
+
 func (s *menu) Run(win *pixelgl.Window) Scene {
 	win.Clear(colornames.Skyblue)
 
@@ -70,7 +74,7 @@ func (s *menu) Run(win *pixelgl.Window) Scene {
 	components.WriteText(text, colorMenu, win, mat)
 
 	if win.JustPressed(pixelgl.KeyEnter) {
-		return s.options[s.getOptionHover()].goTo
+		return s.options[s.getOptionHover()].goTo.Load()
 	}
 
 	if win.JustPressed(pixelgl.KeyDown) {

scenes/ia_hard.go

@@ -8,6 +8,7 @@ import (
 
 // Scene is a interface for scenes
 type Scene interface {
+	Load() Scene
 	Run(win *pixelgl.Window) Scene
 }
 

scenes/menu.go

@@ -32,13 +32,17 @@ func CreateSinglePlayerScene() Scene {
 		status: true,
 	}
 
+	return &s
+}
+
+func (s *singlePlayer) Load() Scene {
 	s.bird = components.NewBird(components.BirdX, components.Sprites["bird10"])
 
 	for i := 0.0; i < 4; i++ {
 		s.obstacles = append(s.obstacles, components.NewPipe(components.WindowWidth+320*i, (components.WindowHeight-components.PipeHeight*2)-rand.Float64()*10*components.PipeHeight))
 	}
 
-	return &s
+	return s
 }
 
 func (s *singlePlayer) Run(win *pixelgl.Window) Scene {
@@ -66,7 +70,7 @@ func (s *singlePlayer) Run(win *pixelgl.Window) Scene {
 	drawFloor(win)
 
 	if s.checkCrash() {
-		return CreateGameOverScene(s.bird.Points)
+		return CreateGameOverScene(s.bird.Points).Load()
 	}
 
 	return s