layer

package
v0.0.0-...-25ab4ef Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 27, 2024 License: MIT Imports: 9 Imported by: 0

Documentation

Overview

Example (Col2im) 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	x := matrix.New(
		[]float64{0, 0, 0, 1},
		[]float64{0, 0, 1, 2},
		[]float64{0, 0, 2, 0},
		[]float64{0, 1, 0, 3},
		[]float64{1, 2, 3, 4},
		[]float64{2, 0, 4, 0},
		[]float64{0, 3, 0, 0},
		[]float64{3, 4, 0, 0},
		[]float64{4, 0, 0, 0},
	)

	xh, xw := 2, 2
	fh, fw := 2, 2
	pad, stride := 1, 1
	for _, r := range layer.Col2im(x, xh, xw, fh, fw, pad, stride) {
		fmt.Printf("%2v\n", r)
	}

}

Output:

[ 4  8]
[12 16]
Example (Im2col) 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	x := matrix.New(
		[]float64{1, 2},
		[]float64{3, 4},
	)

	fh, fw := 2, 2
	pad, stride := 1, 1
	for _, r := range layer.Im2col(x, fh, fw, pad, stride) {
		fmt.Println(r)
	}

}

Output:

[0 0 0 1]
[0 0 1 2]
[0 0 2 0]
[0 1 0 3]
[1 2 3 4]
[2 0 4 0]
[0 3 0 0]
[3 4 0 0]
[4 0 0 0]
Example (Im2col_c2) 
package main

import ()

func main() {
	// N, C, H, W := 1, 2, 2, 2
	// pad := 1
	// [0 0 0 0] [0 0 0 0]
	// [0 1 2 0] [0 5 6 0]
	// [0 3 4 0] [0 7 8 0]
	// [0 0 0 0] [0 0 0 0]
	//
	// FC, FH, FW, stride := 2, 2, 2, 1
	// [0 0 0 0 1 2 0 3 4]
	// [0 0 0 1 2 0 3 4 0]
	// [0 1 2 0 3 4 0 0 0]
	// [1 2 0 3 4 0 0 0 0]
	// [0 0 0 0 5 6 0 7 8]
	// [0 0 0 5 6 0 7 8 0]
	// [0 5 6 0 7 8 0 0 0]
	// [5 6 0 7 8 0 0 0 0]
	//
	// transpose
	// [0 0 0 1 0 0 0 5]
	// [0 0 1 2 0 0 5 6]
	// [0 0 2 0 0 0 6 0]
	// [0 1 0 3 0 5 0 7]
	// [1 2 3 4 5 6 7 8]
	// [2 0 4 0 6 0 8 0]
	// [0 3 0 0 0 7 0 0]
	// [3 4 0 0 7 8 0 0]
	// [4 0 0 0 8 0 0 0]
}

Output:
Example (LossLabel) 
package main

import (
	"fmt"
	"math"
)

func main() {
	t := []int{2, 2}
	y := [][]float64{
		{0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0},
		{0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0},
	}

	f := func(y [][]float64, t []int) float64 {
		var sum float64
		for i := range y {
			sum = sum + math.Log(y[i][t[i]]+1e-7)
		}

		return -1.0 * sum / float64(len(y))
	}

	fmt.Println(f(y, t))

}

Output:

1.406704775046942
Example (Outhw) 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	x := matrix.New([]float64{1, 2}, []float64{3, 4})
	xh, xw := x.Dim()
	fh, fw := 2, 2
	pad, stride := 1, 1

	fmt.Println(layer.Outhw(xh, xw, fh, fw, pad, stride))

}

Output:

3 3
Example (Transpose_broadcast) 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	a := matrix.New([]float64{1, 2, 3}) // (1 ,N)
	ar := a.T().Broadcast(3, 4)         // (1, N) -> (N, 1) -> (N, H)
	for _, r := range ar {
		fmt.Println(r)
	}

}

Output:

[1 1 1 1]
[2 2 2 2]
[3 3 3 3]

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Expand 

func Expand(ds matrix.Matrix, T, N, H int) []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	ds := matrix.Matrix{ // (T, N) (2, 2)
		{2, 4}, // (1, 2)
		{2, 4}, // (1, 2)
	}

	T, N, H := 2, 2, 3
	for _, m := range layer.Expand(ds, T, N, H) {
		for _, r := range m {
			fmt.Println(r)
		}
	}

}

Output:

[2 2 2]
[4 4 4]
[2 2 2]
[4 4 4]

func Loss 

func Loss(y, t matrix.Matrix) float64
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	// https://github.com/oreilly-japan/deep-learning-from-scratch/wiki/errata#%E7%AC%AC3%E5%88%B7%E3%81%BE%E3%81%A7

	t := matrix.New(
		[]float64{0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
		[]float64{0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
	)
	y := matrix.New(
		[]float64{0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0},
		[]float64{0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0},
	)

	fmt.Println(layer.Loss(y, t))

}

Output:

1.406704775046942

Types

type Add 

type Add struct{}

Add is a layer that performs an element-wise addition.

Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	apple := matrix.New([]float64{100.0})
	appleNum := matrix.New([]float64{2.0})
	orange := matrix.New([]float64{150.0})
	orangeNum := matrix.New([]float64{3.0})
	tax := matrix.New([]float64{1.1})

	appleLayer := &layer.Mul{}
	orangeLayer := &layer.Mul{}
	addLayer := &layer.Add{}
	taxLayer := &layer.Mul{}
	fmt.Println(addLayer)

	applePrice := appleLayer.Forward(apple, appleNum)
	orangePrice := orangeLayer.Forward(orange, orangeNum)
	allPrice := addLayer.Forward(applePrice, orangePrice)
	price := taxLayer.Forward(allPrice, tax)

	fmt.Println(price)

	dPrice := matrix.New([]float64{1.0})
	dAllPrice, dTax := taxLayer.Backward(dPrice)
	dApplePrice, dOrangePrice := addLayer.Backward(dAllPrice)
	dOrange, dOrangeNum := orangeLayer.Backward(dOrangePrice)
	dApple, dAppleNum := appleLayer.Backward(dApplePrice)

	fmt.Printf("%v %v\n", dApple, dAppleNum)
	fmt.Printf("%v %v\n", dOrange, dOrangeNum)
	fmt.Println(dTax)

}

Output:

*layer.Add
[[715.0000000000001]]
[[2.2]] [[110.00000000000001]]
[[3.3000000000000003]] [[165]]
[[650]]

func (*Add) Backward 

func (l *Add) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*Add) Forward 

func (l *Add) Forward(x, y matrix.Matrix, _ ...Opts) matrix.Matrix

func (*Add) Grads 

func (l *Add) Grads() []matrix.Matrix

func (*Add) Params 

func (l *Add) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	add := &layer.Add{}

	add.SetParams(make([]matrix.Matrix, 0)...)
	fmt.Println(add.Params())
	fmt.Println(add.Grads())

}

Output:

[]
[]

func (*Add) SetParams 

func (l *Add) SetParams(p ...matrix.Matrix)

func (*Add) String 

func (l *Add) String() string

type Affine 

type Affine struct {
	W, B   matrix.Matrix // params
	DW, DB matrix.Matrix // grads
	// contains filtered or unexported fields
}

Affine is a layer that performs an affine transformation.

Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	affine := &layer.Affine{
		W: matrix.New([]float64{0.1, 0.3, 0.5}, []float64{0.2, 0.4, 0.6}),
		B: matrix.New([]float64{0.1, 0.2, 0.3}),
	}
	fmt.Println(affine)

	// forward
	x := matrix.New([]float64{1.0, 0.5})
	fmt.Println(affine.Forward(x, nil))

	// backward
	fmt.Println(affine.Backward(x))

	// grads
	for _, g := range affine.Grads() {
		fmt.Println(g)
	}

}

Output:

*layer.Affine: W(2, 3), B(1, 3): 9
[[0.30000000000000004 0.7 1.1]]
[[0.25 0.4]] []
[[1 0.5] [0.5 0.25]]
[[1 0.5]]

func (*Affine) Backward 

func (l *Affine) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*Affine) Forward 

func (l *Affine) Forward(x, _ matrix.Matrix, _ ...Opts) matrix.Matrix

func (*Affine) Grads 

func (l *Affine) Grads() []matrix.Matrix

func (*Affine) Params 

func (l *Affine) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	affine := &layer.Affine{}

	affine.SetParams(make([]matrix.Matrix, 2)...)
	fmt.Println(affine.Params())
	fmt.Println(affine.Grads())

}

Output:

[[] []]
[[] []]

func (*Affine) SetParams 

func (l *Affine) SetParams(p ...matrix.Matrix)

func (*Affine) String 

func (l *Affine) String() string

type Attention 

type Attention struct {
	AttentionWeight *AttentionWeight
	WeightSum       *WeightSum
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	at := &layer.Attention{
		AttentionWeight: &layer.AttentionWeight{Softmax: &layer.Softmax{}},
		WeightSum:       &layer.WeightSum{},
	}
	fmt.Println(at)

	// forward
	hs := []matrix.Matrix{
		// (T, N, H) (2, 2, 3)
		{
			{1, 2, 3},
			{4, 5, 6},
		},
		{
			{4, 5, 6},
			{4, 5, 6},
		},
	}
	h := matrix.New(
		// (N, H)
		[]float64{1, 2, 3},
		[]float64{2, 2, 2},
	)
	fmt.Println(at.Forward(hs, h))

	// backward
	da := matrix.Matrix{
		// (T, N) (2, 2)
		{2, 4},
		{2, 4},
	}
	dhs, dh := at.Backward(da)
	fmt.Println(dhs)
	fmt.Println(dh)

}

Output:

*layer.Attention
[[3.5231884244466913 4.403985614959736 5.28478280547278] [4.476811237947822 5.596014047434778 6.7152168569217325]]
[[[-1.8005623649265908e-06 -3.6011247298531815e-06] [2.000003826195054 4.00000360112473]] [[1.7615941559557682 3.5231883119115364] [0.23840584404423598 0.4768116880884711]]]
[[-2.025632674825926e-06 -4.051265360309993e-06 -6.07689804579406e-06] [8.102530758336002e-06 1.0128163447920002e-05 1.2153796137504003e-05]]

func (*Attention) Backward 

func (l *Attention) Backward(dout matrix.Matrix) ([]matrix.Matrix, matrix.Matrix)

func (*Attention) Forward 

func (l *Attention) Forward(hs []matrix.Matrix, h matrix.Matrix) matrix.Matrix

func (*Attention) Grads 

func (l *Attention) Grads() []matrix.Matrix

func (*Attention) Params 

func (l *Attention) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	at := &layer.Attention{}

	at.SetParams(matrix.New())
	fmt.Println(at.Params())
	fmt.Println(at.Grads())

}

Output:

[]
[]

func (*Attention) SetParams 

func (l *Attention) SetParams(p ...matrix.Matrix)

func (*Attention) String 

func (l *Attention) String() string

type AttentionWeight 

type AttentionWeight struct {
	Softmax *Softmax
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	at := &layer.AttentionWeight{
		Softmax: &layer.Softmax{},
	}
	fmt.Println(at)

	// forward
	hs := []matrix.Matrix{
		// (T, N, H) (2, 2, 3)
		{
			{1, 2, 3},
			{4, 5, 6},
		},
		{
			{4, 5, 6},
			{4, 5, 6},
		},
	}
	h := matrix.New(
		[]float64{1, 2, 3},
		[]float64{2, 2, 2},
	)
	fmt.Println(at.Forward(hs, h))

	// backward
	da := matrix.Matrix{
		// (T, N) (2, 2)
		{2, 4},
		{2, 4},
	}
	dhs, dh := at.Backward(da)
	fmt.Println(dhs)
	fmt.Println(dh)

}

Output:

*layer.AttentionWeight
[[1.12535162055095e-07 0.9999998874648379] [0.8807970779778823 0.11920292202211755]]
[[[-2.2507029878186457e-07 -4.5014059756372915e-07 -6.752108963455937e-07] [4.5014059768533343e-07 4.5014059768533343e-07 4.5014059768533343e-07]] [[-0.20998717080701268 -0.41997434161402536 -0.629961512421038] [0.41997434161402614 0.41997434161402614 0.41997434161402614]]]
[[-0.8399489082983495 -1.0499363041756609 -1.2599237000529724] [0.8399495835092476 1.0499369793865596 1.2599243752638714]]

func (*AttentionWeight) Backward 

func (l *AttentionWeight) Backward(da matrix.Matrix) ([]matrix.Matrix, matrix.Matrix)

func (*AttentionWeight) Forward 

func (l *AttentionWeight) Forward(hs []matrix.Matrix, h matrix.Matrix) matrix.Matrix

func (*AttentionWeight) Grads 

func (l *AttentionWeight) Grads() []matrix.Matrix

func (*AttentionWeight) Params 

func (l *AttentionWeight) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	at := &layer.AttentionWeight{}

	at.SetParams(matrix.New())
	fmt.Println(at.Params())
	fmt.Println(at.Grads())

}

Output:

[]
[]

func (*AttentionWeight) SetParams 

func (l *AttentionWeight) SetParams(p ...matrix.Matrix)

func (*AttentionWeight) String 

func (l *AttentionWeight) String() string

type BatchNorm 

type BatchNorm struct {
	Gamma, Beta   matrix.Matrix // params
	DGamma, DBeta matrix.Matrix // grads
	Momentum      float64
	// contains filtered or unexported fields
}

BatchNorm is a layer that performs batch normalization.

Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	x := matrix.New([]float64{1.0, 1.0}, []float64{2.0, 2.0})

	n := &layer.BatchNorm{
		Gamma:    matrix.One(1, len(x[0])),
		Beta:     matrix.Zero(1, len(x[0])),
		Momentum: 0.9,
	}

	fmt.Println(n)
	fmt.Println(n.Forward(x, nil, layer.Opts{Train: true}))
	fmt.Println(n.Forward(x, nil, layer.Opts{Train: false}))
	fmt.Println(n.Backward(x))
	fmt.Println(n.DGamma)
	fmt.Println(n.DBeta)

}

Output:

*layer.BatchNorm: G(1, 2), B(1, 2): 4
[[-0.9999998000000601 -0.9999998000000601] [0.9999998000000601 0.9999998000000601]]
[[5.3758612705744575 5.3758612705744575] [11.700403941838523 11.700403941838523]]
[[-3.9999975998128434e-07 -3.9999975998128434e-07] [3.9999975953719513e-07 3.9999975953719513e-07]] []
[[0.9999998000000601 0.9999998000000601]]
[[3 3]]

func (*BatchNorm) Backward 

func (l *BatchNorm) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*BatchNorm) Forward 

func (l *BatchNorm) Forward(x, _ matrix.Matrix, opts ...Opts) matrix.Matrix

func (*BatchNorm) Grads 

func (l *BatchNorm) Grads() []matrix.Matrix

func (*BatchNorm) Params 

func (l *BatchNorm) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	n := &layer.BatchNorm{}

	n.SetParams(make([]matrix.Matrix, 2)...)
	fmt.Println(n.Params())
	fmt.Println(n.Grads())

}

Output:

[[] []]
[[] []]

func (*BatchNorm) SetParams 

func (l *BatchNorm) SetParams(p ...matrix.Matrix)

func (*BatchNorm) String 

func (l *BatchNorm) String() string

type Dot 

type Dot struct {
	W  matrix.Matrix // params
	DW matrix.Matrix // grads
	// contains filtered or unexported fields
}

Dot is a layer that performs a dot product.

Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	W := matrix.New(
		[]float64{5, 6},
		[]float64{7, 8},
	)
	dot := &layer.Dot{W: W}
	fmt.Println(dot)
	fmt.Println()

	// forward
	A := matrix.New(
		[]float64{1, 2},
		[]float64{3, 4},
	)

	for _, r := range dot.Forward(A, nil) {
		fmt.Println(r)
	}
	fmt.Println()

	// backward
	dx, _ := dot.Backward(matrix.New([]float64{1, 0}, []float64{0, 1}))
	for _, r := range dx {
		fmt.Println(r)
	}
	fmt.Println()

}

Output:

*layer.Dot: W(2, 2): 4

[19 22]
[43 50]

[5 7]
[6 8]

func (*Dot) Backward 

func (l *Dot) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*Dot) Forward 

func (l *Dot) Forward(x, _ matrix.Matrix, _ ...Opts) matrix.Matrix

func (*Dot) Grads 

func (l *Dot) Grads() []matrix.Matrix

func (*Dot) Params 

func (l *Dot) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	dot := &layer.Dot{}
	dot.SetParams(make([]matrix.Matrix, 1)...)

	fmt.Println(dot.Params())
	fmt.Println(dot.Grads())

}

Output:

[[]]
[[]]

func (*Dot) SetParams 

func (l *Dot) SetParams(p ...matrix.Matrix)

func (*Dot) String 

func (l *Dot) String() string

type Dropout 

type Dropout struct {
	Ratio float64
	// contains filtered or unexported fields
}

Dropout is a layer that performs a dropout.

Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
	"github.com/itsubaki/neu/math/rand"
)

func main() {
	x := matrix.New([]float64{1.0, -0.5}, []float64{-2.0, 3.0})
	s := rand.Const(1)

	drop := &layer.Dropout{}
	fmt.Println(drop)

	drop.Ratio = 0.0
	fmt.Println(drop.Forward(x, nil, layer.Opts{Train: true, Source: s}))
	fmt.Println(drop.Backward(x))
	fmt.Println(drop.Forward(x, nil, layer.Opts{Train: false}))
	fmt.Println(drop.Backward(x))
	fmt.Println()

	drop.Ratio = 1.0
	fmt.Println(drop.Forward(x, nil, layer.Opts{Train: true, Source: s}))
	fmt.Println(drop.Backward(x))
	fmt.Println(drop.Forward(x, nil, layer.Opts{Train: false}))
	fmt.Println(drop.Backward(x))
	fmt.Println()

	drop.Ratio = 0.5
	fmt.Println(drop.Forward(x, nil, layer.Opts{Train: true, Source: s}))
	fmt.Println(drop.Backward(x))
	fmt.Println(drop.Forward(x, nil, layer.Opts{Train: false}))
	fmt.Println(drop.Backward(x))

}

Output:

*layer.Dropout: Ratio(0)
[[1 -0.5] [-2 3]]
[[1 -0.5] [-2 3]] []
[[1 -0.5] [-2 3]]
[[1 -0.5] [-2 3]] []

[[0 -0] [-0 0]]
[[0 -0] [-0 0]] []
[[0 -0] [-0 0]]
[[0 -0] [-0 0]] []

[[1 -0] [-0 0]]
[[1 -0] [-0 0]] []
[[0.5 -0.25] [-1 1.5]]
[[1 -0] [-0 0]] []

func (*Dropout) Backward 

func (l *Dropout) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*Dropout) Forward 

func (l *Dropout) Forward(x, _ matrix.Matrix, opts ...Opts) matrix.Matrix

func (*Dropout) Grads 

func (l *Dropout) Grads() []matrix.Matrix

func (*Dropout) Params 

func (l *Dropout) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	drop := &layer.Dropout{Ratio: 0.5}

	drop.SetParams(make([]matrix.Matrix, 0)...)
	fmt.Println(drop.Params())
	fmt.Println(drop.Grads())

}

Output:

[]
[]

func (*Dropout) SetParams 

func (l *Dropout) SetParams(p ...matrix.Matrix)

func (*Dropout) String 

func (l *Dropout) String() string

type Embedding 

type Embedding struct {
	W  matrix.Matrix // params
	DW matrix.Matrix // grads
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	embed := &layer.Embedding{W: matrix.New(
		[]float64{0.0, 0.1, 0.2},
		[]float64{0.1, 0.2, 0.3},
		[]float64{0.2, 0.3, 0.4},
		[]float64{0.3, 0.4, 0.5},
		[]float64{0.4, 0.5, 0.6},
		[]float64{0.5, 0.6, 0.7},
	)}
	fmt.Println(embed)

	// forward
	// p138
	x := matrix.New(
		[]float64{0},
		[]float64{2},
		[]float64{0},
		[]float64{4},
	)
	fmt.Println(embed.Forward(x, nil))

	// backward
	dh := matrix.New(
		[]float64{9.0, 9.1, 9.2},
		[]float64{9.1, 9.2, 9.3},
		[]float64{9.2, 9.3, 9.4},
		[]float64{9.3, 9.4, 9.5},
	)

	embed.Backward(dh)
	fmt.Println(embed.DW)

}

Output:

*layer.Embedding: W(6, 3): 18
[[0 0.1 0.2] [0.2 0.3 0.4] [0 0.1 0.2] [0.4 0.5 0.6]]
[[18.2 18.4 18.6] [0 0 0] [9.1 9.2 9.3] [0 0 0] [9.3 9.4 9.5] [0 0 0]]

func (*Embedding) Backward 

func (l *Embedding) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*Embedding) Forward 

func (l *Embedding) Forward(idx, _ matrix.Matrix, _ ...Opts) matrix.Matrix

func (*Embedding) Grads 

func (l *Embedding) Grads() []matrix.Matrix

func (*Embedding) Params 

func (l *Embedding) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	l := &layer.Embedding{}

	l.SetParams(make([]matrix.Matrix, 2)...)
	fmt.Println(l.Params())
	fmt.Println(l.Grads())

}

Output:

[[]]
[[]]

func (*Embedding) SetParams 

func (l *Embedding) SetParams(p ...matrix.Matrix)

func (*Embedding) String 

func (l *Embedding) String() string

type EmbeddingDot 

type EmbeddingDot struct {
	Embedding Embedding
	H, W      matrix.Matrix
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	// p150
	l := &layer.EmbeddingDot{
		Embedding: layer.Embedding{
			W: matrix.New(
				[]float64{0, 1, 2},
				[]float64{3, 4, 5},
				[]float64{6, 7, 8},
				[]float64{9, 10, 11},
				[]float64{12, 13, 14},
				[]float64{15, 16, 17},
				[]float64{18, 17, 18},
			),
		},
	}
	fmt.Println(l)

	// forward
	h := matrix.New(
		[]float64{0, 1, 2},
		[]float64{3, 4, 5},
		[]float64{6, 7, 8},
	)

	idx := matrix.New(
		[]float64{0},
		[]float64{3},
		[]float64{1},
	)

	out := l.Forward(h, idx)
	for _, r := range out {
		fmt.Println(r)
	}
	fmt.Println()

	// backward
	dout := matrix.New([]float64{1})
	dh, _ := l.Backward(dout)
	for _, r := range dh {
		fmt.Println(r)
	}

}

Output:

*layer.EmbeddingDot: W(7, 3): 21
[5 122 86]

[0 1 2]
[9 10 11]
[3 4 5]

func (*EmbeddingDot) Backward 

func (l *EmbeddingDot) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*EmbeddingDot) Forward 

func (l *EmbeddingDot) Forward(h, idx matrix.Matrix, _ ...Opts) matrix.Matrix

func (*EmbeddingDot) Grads 

func (l *EmbeddingDot) Grads() []matrix.Matrix

func (*EmbeddingDot) Params 

func (l *EmbeddingDot) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	l := &layer.EmbeddingDot{}

	l.SetParams(make([]matrix.Matrix, 2)...)
	fmt.Println(l.Params())
	fmt.Println(l.Grads())

}

Output:

[[]]
[[]]

func (*EmbeddingDot) SetParams 

func (l *EmbeddingDot) SetParams(p ...matrix.Matrix)

func (*EmbeddingDot) String 

func (l *EmbeddingDot) String() string

type GRU 

type GRU struct {
	Wx, Wh, B    matrix.Matrix // params
	DWx, DWh, DB matrix.Matrix // grads
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	gru := &layer.GRU{
		Wx: matrix.New(
			// (D, 3H)
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
		),
		Wh: matrix.New(
			// (H, 3H)
			[]float64{0.1, 0.2, 0.3},
		),
		B: matrix.New(
			// (1, 3H)
			[]float64{0, 0, 0},
		),
	}
	fmt.Println(gru)

	// forward
	x := matrix.New(
		// (N, D)
		[]float64{0.1, 0.2, 0.3},
		[]float64{0.3, 0.4, 0.5},
	)
	h := matrix.New(
		// (N, H)
		[]float64{1},
		[]float64{1},
	)
	hNext := gru.Forward(x, h)
	fmt.Println(hNext)

	// backward
	dhNext := matrix.New(
		[]float64{1},
		[]float64{1},
	)
	dx, dhprev := gru.Backward(dhNext)
	fmt.Println(dx)
	fmt.Println(dhprev)

}

Output:

*layer.GRU: Wx(3, 3), Wh(1, 3), B(1, 3): 15
[[0.6435151783703015] [0.7197594876758177]]
[[0.19802226281185067 0.19802226281185067 0.19802226281185067] [0.17355749298151332 0.17355749298151332 0.17355749298151332]]
[[0.5336723979435917] [0.5151767843512871]]

func (*GRU) Backward 

func (l *GRU) Backward(dhnext matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*GRU) Forward 

func (l *GRU) Forward(x, h matrix.Matrix, _ ...Opts) matrix.Matrix

func (*GRU) Grads 

func (l *GRU) Grads() []matrix.Matrix

func (*GRU) Params 

func (l *GRU) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	gru := &layer.GRU{}

	gru.SetParams(make([]matrix.Matrix, 3)...)
	fmt.Println(gru.Params())
	fmt.Println(gru.Grads())

}

Output:

[[] [] []]
[[] [] []]

func (*GRU) SetParams 

func (l *GRU) SetParams(p ...matrix.Matrix)

func (*GRU) String 

func (l *GRU) String() string

type LSTM 

type LSTM struct {
	Wx, Wh, B    matrix.Matrix // params
	DWx, DWh, DB matrix.Matrix // grads
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	lstm := &layer.LSTM{
		Wx: matrix.New(
			// (D, 4H)
			[]float64{0.1, 0.2, 0.3, 0.4},
			[]float64{0.1, 0.2, 0.3, 0.4},
			[]float64{0.1, 0.2, 0.3, 0.4},
		),
		Wh: matrix.New(
			// (D, 4H)
			[]float64{0.1, 0.2, 0.3, 0.4},
			[]float64{0.1, 0.2, 0.3, 0.4},
			[]float64{0.1, 0.2, 0.3, 0.4},
		),
		B: matrix.New(
			// (1, 4H)
			[]float64{0, 0, 0, 0},
		),
	}
	fmt.Println(lstm)

	// forward
	x := matrix.New(
		// (N, D)
		[]float64{0.1, 0.2, 0.3},
		[]float64{0.3, 0.4, 0.5},
	)
	h := matrix.New(
		// (N, H)
		[]float64{1},
		[]float64{1},
	)
	c := matrix.New(
		// (N, H)
		[]float64{1},
		[]float64{2},
	)

	hNext, cNext := lstm.Forward(x, h, c)
	fmt.Println(hNext)
	fmt.Println(cNext)

	// backward
	dhNext := matrix.New(
		[]float64{1},
		[]float64{1},
	)
	dcNext := matrix.New(
		[]float64{1},
		[]float64{1},
	)

	dx, dhPrev, dcPrev := lstm.Backward(dhNext, dcNext)
	fmt.Println(dx)
	fmt.Println(dhPrev)
	fmt.Println(dcPrev)

}

Output:

*layer.LSTM: Wx(3, 4), Wh(3, 4), B(1, 4): 28
[[0.4083993715020527] [0.6230325858147007]]
[[0.7311121273610465] [1.382257865851477]]
[[0.2782747345210347 0.2782747345210347 0.2782747345210347] [0.2890431140697133 0.2890431140697133 0.2890431140697133]]
[[0.2782747345210347 0.2782747345210347 0.2782747345210347] [0.2890431140697133 0.2890431140697133 0.2890431140697133]]
[[0.7558896314112273] [0.6422382397686938]]

func (*LSTM) Backward 

func (l *LSTM) Backward(dhNext, dcNext matrix.Matrix) (matrix.Matrix, matrix.Matrix, matrix.Matrix)

func (*LSTM) Forward 

func (l *LSTM) Forward(x, h, c matrix.Matrix, _ ...Opts) (matrix.Matrix, matrix.Matrix)

func (*LSTM) Grads 

func (l *LSTM) Grads() []matrix.Matrix

func (*LSTM) Params 

func (l *LSTM) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	lstm := &layer.LSTM{}

	lstm.SetParams(make([]matrix.Matrix, 3)...)
	fmt.Println(lstm.Params())
	fmt.Println(lstm.Grads())

}

Output:

[[] [] []]
[[] [] []]

func (*LSTM) SetParams 

func (l *LSTM) SetParams(p ...matrix.Matrix)

func (*LSTM) String 

func (l *LSTM) String() string

type MeanSquaredError 

type MeanSquaredError struct {
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	l := &layer.MeanSquaredError{}
	fmt.Println(l)

	// forward
	y := matrix.New(
		[]float64{0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0},
		[]float64{0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0},
	)
	t := matrix.New(
		[]float64{0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
		[]float64{0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
	)
	loss := l.Forward(y, t)
	fmt.Println(loss)

	// backward
	dout := matrix.New([]float64{1})
	gx0, gx1 := l.Backward(dout)
	for _, r := range gx0 {
		fmt.Printf("%.4f\n", r)
	}

	for _, r := range gx1 {
		fmt.Printf("%.4f\n", r)
	}

}

Output:

*layer.MeanSquaredError
[[0.0695]]
[0.0100 0.0050 -0.0400 0.0000 0.0050 0.0100 0.0000 0.0100 0.0000 0.0000]
[0.0100 0.0050 -0.0900 0.0000 0.0050 0.0100 0.0000 0.0600 0.0000 0.0000]
[-0.0100 -0.0050 0.0400 -0.0000 -0.0050 -0.0100 -0.0000 -0.0100 -0.0000 -0.0000]
[-0.0100 -0.0050 0.0900 -0.0000 -0.0050 -0.0100 -0.0000 -0.0600 -0.0000 -0.0000]

func (*MeanSquaredError) Backward 

func (l *MeanSquaredError) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	f := func(target, q matrix.Matrix) (matrix.Matrix, matrix.Matrix, matrix.Matrix) {
		l := &layer.MeanSquaredError{}
		loss := l.Forward(target, q)
		gx0, gx1 := l.Backward(matrix.New([]float64{1}))
		return loss, gx0, gx1
	}

	y, t := matrix.New([]float64{0.2}), matrix.New([]float64{0.1})
	fmt.Println(f(y, t))
	fmt.Println(f(y.Broadcast(1, 4), t.Broadcast(1, 4)))

}

Output:

[[0.010000000000000002]] [[0.2]] [[-0.2]]
[[0.010000000000000002]] [[0.05 0.05 0.05 0.05]] [[-0.05 -0.05 -0.05 -0.05]]

func (*MeanSquaredError) Forward 

func (l *MeanSquaredError) Forward(y, t matrix.Matrix, _ ...Opts) matrix.Matrix

func (*MeanSquaredError) Grads 

func (l *MeanSquaredError) Grads() []matrix.Matrix

func (*MeanSquaredError) Params 

func (l *MeanSquaredError) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	l := &layer.MeanSquaredError{}

	l.SetParams(make([]matrix.Matrix, 0)...)
	fmt.Println(l.Params())
	fmt.Println(l.Grads())

}

Output:

[]
[]

func (*MeanSquaredError) SetParams 

func (l *MeanSquaredError) SetParams(p ...matrix.Matrix)

func (*MeanSquaredError) String 

func (l *MeanSquaredError) String() string

type Mul 

type Mul struct {
	// contains filtered or unexported fields
}

Mul is a layer that performs an element-wise multiplication.

Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	apple := matrix.New([]float64{100.0})
	appleNum := matrix.New([]float64{2.0})
	tax := matrix.New([]float64{1.1})

	appleLayer := &layer.Mul{}
	taxLayer := &layer.Mul{}
	fmt.Println(taxLayer)

	applePrice := appleLayer.Forward(apple, appleNum)
	price := taxLayer.Forward(applePrice, tax)

	fmt.Println(price)

	dPrice := matrix.New([]float64{1.0})
	dApplePrice, dTax := taxLayer.Backward(dPrice)
	dApple, dAppleNum := appleLayer.Backward(dApplePrice)

	fmt.Printf("%v %v %v\n", dApple, dAppleNum, dTax)

}

Output:

*layer.Mul
[[220.00000000000003]]
[[2.2]] [[110.00000000000001]] [[200]]

func (*Mul) Backward 

func (l *Mul) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*Mul) Forward 

func (l *Mul) Forward(x, y matrix.Matrix, _ ...Opts) matrix.Matrix

func (*Mul) Grads 

func (l *Mul) Grads() []matrix.Matrix

func (*Mul) Params 

func (l *Mul) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	mul := &layer.Mul{}

	mul.SetParams(make([]matrix.Matrix, 0)...)
	fmt.Println(mul.Params())
	fmt.Println(mul.Grads())

}

Output:

[]
[]

func (*Mul) SetParams 

func (l *Mul) SetParams(p ...matrix.Matrix)

func (*Mul) String 

func (l *Mul) String() string

type NegativeSamplingLoss 

type NegativeSamplingLoss struct {
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
	"github.com/itsubaki/neu/math/rand"
)

func main() {
	W := matrix.New(
		// (V, H) = (7, 5)
		[]float64{0.1, 0.1, 0.1, 0.1, 0.1},
		[]float64{0.1, 0.1, 0.1, 0.1, 0.1},
		[]float64{0.1, 0.1, 0.1, 0.1, 0.1},
		[]float64{0.1, 0.1, 0.1, 0.1, 0.1},
		[]float64{0.1, 0.1, 0.1, 0.1, 0.1},
		[]float64{0.1, 0.1, 0.1, 0.1, 0.1},
		[]float64{0.1, 0.1, 0.1, 0.1, 0.1},
	)
	// you say goodbye and i say hello.
	corpus := []int{0, 1, 2, 3, 4, 1, 5, 6}
	power := 0.75
	sampleSize := 2

	s := rand.Const(1)
	l := layer.NewNegativeSamplingLoss(W, corpus, power, sampleSize, s)
	fmt.Println(l)

	// forward
	target := matrix.New(
		// (3, 1)
		[]float64{0},
		[]float64{1},
		[]float64{2},
	)

	h := matrix.New(
		// (3, 5)
		[]float64{0.1, 0.1, 0.1, 0.1, 0.1},
		[]float64{0.1, 0.1, 0.1, 0.1, 0.1},
		[]float64{0.1, 0.1, 0.1, 0.1, 0.1},
	)

	loss := l.Forward(h, target)
	dh, _ := l.Backward(matrix.New([]float64{1.0}))
	fmt.Println(loss)
	for _, r := range dh {
		fmt.Println(r)
	}

}

Output:

*layer.NegativeSamplingLoss: W(7, 5)*3: 105
[[6.316135015988275]]
[0.0537492189452631 0.0537492189452631 0.0537492189452631 0.0537492189452631 0.0537492189452631]
[0.0537492189452631 0.0537492189452631 0.0537492189452631 0.0537492189452631 0.0537492189452631]
[0.0537492189452631 0.0537492189452631 0.0537492189452631 0.0537492189452631 0.0537492189452631]

func NewNegativeSamplingLoss 

func NewNegativeSamplingLoss(W matrix.Matrix, corpus []int, power float64, sampleSize int, s ...randv2.Source) *NegativeSamplingLoss

func (*NegativeSamplingLoss) Backward 

func (l *NegativeSamplingLoss) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*NegativeSamplingLoss) Forward 

func (l *NegativeSamplingLoss) Forward(h, target matrix.Matrix, _ ...Opts) matrix.Matrix

func (*NegativeSamplingLoss) Grads 

func (l *NegativeSamplingLoss) Grads() []matrix.Matrix

func (*NegativeSamplingLoss) Params 

func (l *NegativeSamplingLoss) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	W := matrix.New([]float64{0.1, 0.1, 0.1})
	corpus := []int{0, 1, 2, 3, 4, 5, 6}
	power := 0.75
	sampleSize := 2
	l := layer.NewNegativeSamplingLoss(W, corpus, power, sampleSize)

	l.SetParams(make([]matrix.Matrix, sampleSize+1)...)
	fmt.Println(l.Params())
	fmt.Println(l.Grads())

}

Output:

[[] [] []]
[[] [] []]

func (*NegativeSamplingLoss) SetParams 

func (l *NegativeSamplingLoss) SetParams(p ...matrix.Matrix)

func (*NegativeSamplingLoss) String 

func (l *NegativeSamplingLoss) String() string

type Opts 

type Opts struct {
	Train  bool
	Source randv2.Source
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
)

func main() {
	fmt.Println(layer.Opts{Train: true})

}

Output:

{true <nil>}

type RNN 

type RNN struct {
	Wx, Wh, B    matrix.Matrix // params
	DWx, DWh, DB matrix.Matrix // grads
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	rnn := &layer.RNN{
		Wx: matrix.New(
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
		),
		Wh: matrix.New(
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
		),
		B: matrix.New([]float64{0, 0, 0}),
	}
	fmt.Println(rnn)

	// forward
	x := matrix.New(
		[]float64{0.1, 0.2, 0.3},
		[]float64{0.3, 0.4, 0.5},
	)
	hPrev := matrix.New(
		[]float64{1, 2, 3},
		[]float64{1, 2, 3},
	)

	hNext := rnn.Forward(x, hPrev)
	fmt.Print(hNext.Dim())
	fmt.Println(":", hNext)

	// backward
	dhNext := matrix.New(
		[]float64{0.1, 0.2, 0.3},
		[]float64{0.3, 0.4, 0.5},
	)

	dx, dhPrev := rnn.Backward(dhNext)
	fmt.Print(dx.Dim())
	fmt.Println(":", dx)
	fmt.Print(dhPrev.Dim())
	fmt.Println(":", dhPrev)
	fmt.Println()

	// grads
	for _, g := range rnn.Grads() {
		fmt.Println(g)
	}

}

Output:

*layer.RNN: Wx(3, 3), Wh(3, 3), B(1, 3): 21
2 3: [[0.5783634130445059 0.8667839288498187 0.9625869800912907] [0.616909302877065 0.8936977272038726 0.9737493633257944]]
2 3: [[0.02321074997030762 0.02321074997030762 0.02321074997030762] [0.04245886376535411 0.04245886376535411 0.04245886376535411]]
2 3: [[0.02321074997030762 0.02321074997030762 0.02321074997030762] [0.04245886376535411 0.04245886376535411 0.04245886376535411]]

[[0.06240301970665113 0.02913023710062935 0.009974615786153376] [0.08764066469187826 0.0421561244100081 0.01476801383004575] [0.11287830967710537 0.055182011719386845 0.019561411873938124]]
[[0.25237644985227115 0.13025887309378748 0.04793398043892374] [0.5047528997045423 0.26051774618757495 0.09586796087784748] [0.7571293495568134 0.3907766192813624 0.1438019413167712]]
[[0.25237644985227115 0.13025887309378748 0.04793398043892374]]

func (*RNN) Backward 

func (l *RNN) Backward(dhNext matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*RNN) Forward 

func (l *RNN) Forward(x, h matrix.Matrix, _ ...Opts) matrix.Matrix

func (*RNN) Grads 

func (l *RNN) Grads() []matrix.Matrix

func (*RNN) Params 

func (l *RNN) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	rnn := &layer.RNN{}

	rnn.SetParams(make([]matrix.Matrix, 3)...)
	fmt.Println(rnn.Params())
	fmt.Println(rnn.Grads())

}

Output:

[[] [] []]
[[] [] []]

func (*RNN) SetParams 

func (l *RNN) SetParams(p ...matrix.Matrix)

func (*RNN) String 

func (l *RNN) String() string

type ReLU 

type ReLU struct {
	// contains filtered or unexported fields
}

ReLU is a layer that performs an element-wise ReLU.

Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	relu := &layer.ReLU{}
	fmt.Println(relu)

	// forward
	x := matrix.New([]float64{1.0, -0.5}, []float64{-2.0, 3.0})
	fmt.Println(relu.Forward(x, nil))

	// backward
	fmt.Println(relu.Backward(x))

}

Output:

*layer.ReLU
[[1 -0] [-0 3]]
[[1 -0] [-0 3]] []

func (*ReLU) Backward 

func (l *ReLU) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*ReLU) Forward 

func (l *ReLU) Forward(x, _ matrix.Matrix, _ ...Opts) matrix.Matrix

func (*ReLU) Grads 

func (l *ReLU) Grads() []matrix.Matrix

func (*ReLU) Params 

func (l *ReLU) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	relu := &layer.ReLU{}

	relu.SetParams(make([]matrix.Matrix, 0)...)
	fmt.Println(relu.Params())
	fmt.Println(relu.Grads())

}

Output:

[]
[]

func (*ReLU) SetParams 

func (l *ReLU) SetParams(p ...matrix.Matrix)

func (*ReLU) String 

func (l *ReLU) String() string

type Sigmoid 

type Sigmoid struct {
	// contains filtered or unexported fields
}

Sigmoid is a layer that performs an element-wise sigmoid.

Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	sigmoid := &layer.Sigmoid{}
	fmt.Println(sigmoid)

	// forward
	x := matrix.New([]float64{0.0})
	fmt.Println(sigmoid.Forward(x, nil))

	// backward
	fmt.Println(sigmoid.Backward(x))

}

Output:

*layer.Sigmoid
[[0.5]]
[[0]] []

func (*Sigmoid) Backward 

func (l *Sigmoid) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*Sigmoid) Forward 

func (l *Sigmoid) Forward(x, _ matrix.Matrix, _ ...Opts) matrix.Matrix

func (*Sigmoid) Grads 

func (l *Sigmoid) Grads() []matrix.Matrix

func (*Sigmoid) Params 

func (l *Sigmoid) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	sigmoid := &layer.Sigmoid{}

	sigmoid.SetParams(make([]matrix.Matrix, 0)...)
	fmt.Println(sigmoid.Params())
	fmt.Println(sigmoid.Grads())

}

Output:

[]
[]

func (*Sigmoid) SetParams 

func (l *Sigmoid) SetParams(p ...matrix.Matrix)

func (*Sigmoid) String 

func (l *Sigmoid) String() string

type SigmoidWithLoss 

type SigmoidWithLoss struct {
	// contains filtered or unexported fields
}

SigmoidWithLoss is a layer that performs a sigmoid and a cross-entropy loss.

Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	l := &layer.SigmoidWithLoss{}
	fmt.Println(l)

	// forward
	x := matrix.New(
		[]float64{0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0},
		[]float64{0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0},
	)
	t := matrix.New(
		[]float64{0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
		[]float64{0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
	)
	loss := l.Forward(x, t)
	fmt.Println(loss)

	// backward
	dx, _ := l.Backward(matrix.New([]float64{1.0}))
	fmt.Println(dx)

}

Output:

*layer.SigmoidWithLoss
[[7.130183898637823]]
[[0.26248959373947 0.25624869824210517 -0.1771718468871023 0.25 0.25624869824210517 0.26248959373947 0.25 0.26248959373947 0.25 0.25] [0.26248959373947 0.25624869824210517 -0.23751040626053 0.25 0.25624869824210517 0.26248959373947 0.25 0.3228281531128977 0.25 0.25]]

func (*SigmoidWithLoss) Backward 

func (l *SigmoidWithLoss) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*SigmoidWithLoss) Forward 

func (l *SigmoidWithLoss) Forward(x, t matrix.Matrix, _ ...Opts) matrix.Matrix

func (*SigmoidWithLoss) Grads 

func (l *SigmoidWithLoss) Grads() []matrix.Matrix

func (*SigmoidWithLoss) Params 

func (l *SigmoidWithLoss) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	l := &layer.SigmoidWithLoss{}

	l.SetParams(make([]matrix.Matrix, 0)...)
	fmt.Println(l.Params())
	fmt.Println(l.Grads())

}

Output:

[]
[]

func (*SigmoidWithLoss) SetParams 

func (l *SigmoidWithLoss) SetParams(p ...matrix.Matrix)

func (*SigmoidWithLoss) String 

func (l *SigmoidWithLoss) String() string

type Softmax 

type Softmax struct {
	// contains filtered or unexported fields
}

Softmax is a layer that performs a softmax.

Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	softmax := &layer.Softmax{}
	fmt.Println(softmax)

	// forward
	x := matrix.New(
		[]float64{2, 2, 6},
		[]float64{4, 3, 3},
	)
	out := softmax.Forward(x, nil)
	for _, r := range out {
		fmt.Println(r)
	}

	// backward
	dx, _ := softmax.Backward(x)
	fmt.Println(dx)

}

Output:

*layer.Softmax
[0.017668422014048047 0.017668422014048047 0.9646631559719038]
[0.5761168847658291 0.21194155761708544 0.21194155761708544]
[[-0.0681763029644602 -0.0681763029644602 0.13635260592892173] [0.2442062198535453 -0.12210310992677276 -0.12210310992677276]]

func (*Softmax) Backward 

func (l *Softmax) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*Softmax) Forward 

func (l *Softmax) Forward(x, _ matrix.Matrix, _ ...Opts) matrix.Matrix

func (*Softmax) Grads 

func (l *Softmax) Grads() []matrix.Matrix

func (*Softmax) Params 

func (l *Softmax) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	softmax := &layer.Softmax{}

	softmax.SetParams(make([]matrix.Matrix, 0)...)
	fmt.Println(softmax.Params())
	fmt.Println(softmax.Grads())

}

Output:

[]
[]

func (*Softmax) SetParams 

func (l *Softmax) SetParams(p ...matrix.Matrix)

func (*Softmax) String 

func (l *Softmax) String() string

type SoftmaxWithLoss 

type SoftmaxWithLoss struct {
	// contains filtered or unexported fields
}

SoftmaxWithLoss is a layer that performs a softmax and a cross-entropy loss.

Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	l := &layer.SoftmaxWithLoss{}
	fmt.Println(l)

	// forward
	x := matrix.New(
		[]float64{0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0},
		[]float64{0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0},
	)
	t := matrix.New(
		[]float64{0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
		[]float64{0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
	)
	loss := l.Forward(x, t)
	fmt.Println(loss)

	// backward
	dout := matrix.New([]float64{1})
	dx, _ := l.Backward(dout)
	for _, r := range dx {
		fmt.Println(r)
	}

}

Output:

*layer.SoftmaxWithLoss
[[2.0694934853340516]]
[0.04916164744936827 0.04676400561076958 -0.41894614614756587 0.044483298144480495 0.04676400561076958 0.04916164744936827 0.044483298144480495 0.04916164744936827 0.044483298144480495 0.044483298144480495]
[0.04916164744936827 0.04676400561076958 -0.45083835255063176 0.044483298144480495 0.04676400561076958 0.04916164744936827 0.044483298144480495 0.08105385385243416 0.044483298144480495 0.044483298144480495]

func (*SoftmaxWithLoss) Backward 

func (l *SoftmaxWithLoss) Backward(dout matrix.Matrix) (matrix.Matrix, matrix.Matrix)

func (*SoftmaxWithLoss) Forward 

func (l *SoftmaxWithLoss) Forward(x, t matrix.Matrix, _ ...Opts) matrix.Matrix

func (*SoftmaxWithLoss) Grads 

func (l *SoftmaxWithLoss) Grads() []matrix.Matrix

func (*SoftmaxWithLoss) Params 

func (l *SoftmaxWithLoss) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	l := &layer.SoftmaxWithLoss{}

	l.SetParams(make([]matrix.Matrix, 0)...)
	fmt.Println(l.Params())
	fmt.Println(l.Grads())

}

Output:

[]
[]

func (*SoftmaxWithLoss) SetParams 

func (l *SoftmaxWithLoss) SetParams(p ...matrix.Matrix)

func (*SoftmaxWithLoss) String 

func (l *SoftmaxWithLoss) String() string

type TimeAffine 

type TimeAffine struct {
	W, B   matrix.Matrix // params
	DW, DB matrix.Matrix // grads
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	affine := &layer.TimeAffine{
		W: matrix.New([]float64{0.1, 0.3, 0.5}, []float64{0.2, 0.4, 0.6}),
		B: matrix.New([]float64{0.1, 0.2, 0.3}),
	}
	fmt.Println(affine)

	// forward
	xs := []matrix.Matrix{{{1.0, 0.5}}}
	fmt.Println(affine.Forward(xs, nil))

	// backward
	fmt.Println(affine.Backward(xs))

	// grads
	for _, g := range affine.Grads() {
		fmt.Println(g)
	}

}

Output:

*layer.TimeAffine: W(2, 3), B(1, 3): 9
[[[0.30000000000000004 0.7 1.1]]]
[[[0.25 0.4]]]
[[1 0.5] [0.5 0.25]]
[[1 0.5]]
Example (Time2) 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	affine := &layer.TimeAffine{
		W: matrix.New([]float64{0.1, 0.3, 0.5}, []float64{0.2, 0.4, 0.6}),
		B: matrix.New([]float64{0.1, 0.2, 0.3}),
	}
	fmt.Println(affine)

	// forward
	xs := []matrix.Matrix{
		{{1.0, 0.5}},
		{{1.0, 0.5}},
	}
	fmt.Println(affine.Forward(xs, nil))

	// backward
	fmt.Println(affine.Backward(xs))

	// grads
	for _, g := range affine.Grads() {
		fmt.Println(g)
	}

}

Output:

*layer.TimeAffine: W(2, 3), B(1, 3): 9
[[[0.30000000000000004 0.7 1.1]] [[0.30000000000000004 0.7 1.1]]]
[[[0.25 0.4]] [[0.25 0.4]]]
[[2 1] [1 0.5]]
[[2 1]]

func (*TimeAffine) Backward 

func (l *TimeAffine) Backward(dout []matrix.Matrix) []matrix.Matrix

func (*TimeAffine) Forward 

func (l *TimeAffine) Forward(xs, _ []matrix.Matrix, _ ...Opts) []matrix.Matrix

func (*TimeAffine) Grads 

func (l *TimeAffine) Grads() []matrix.Matrix

func (*TimeAffine) Params 

func (l *TimeAffine) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	affine := &layer.TimeAffine{}

	affine.SetParams(make([]matrix.Matrix, 2)...)
	fmt.Println(affine.Params())
	fmt.Println(affine.Grads())

}

Output:

[[] []]
[[] []]

func (*TimeAffine) ResetState 

func (l *TimeAffine) ResetState()

func (*TimeAffine) SetParams 

func (l *TimeAffine) SetParams(p ...matrix.Matrix)

func (*TimeAffine) SetState 

func (l *TimeAffine) SetState(_ ...matrix.Matrix)
Example 
package main

import (
	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	affine := &layer.TimeAffine{}
	affine.SetState(matrix.New())
	affine.ResetState()

}

Output:

func (*TimeAffine) String 

func (l *TimeAffine) String() string

type TimeAttention 

type TimeAttention struct {
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	at := &layer.TimeAttention{}
	fmt.Println(at)

	// forward
	hsenc := []matrix.Matrix{
		// (T, N, H) (2, 2, 3)
		{
			{1, 2, 3},
			{4, 5, 6},
		},
		{
			{4, 5, 6},
			{4, 5, 6},
		},
	}

	hsdec := []matrix.Matrix{
		// (T, N, H) (2, 2, 3)
		{
			{1, 2, 3},
			{4, 5, 6},
		},
		{
			{4, 5, 6},
			{4, 5, 6},
		},
	}

	fmt.Println(at.Forward(hsenc, hsdec))

	// backward
	dout := []matrix.Matrix{
		{
			{1, 2, 3},
			{4, 5, 6},
		},
		{
			{4, 5, 6},
			{4, 5, 6},
		},
	}
	dhs, dh := at.Backward(dout)
	fmt.Println(dhs)
	fmt.Println(dh)

}

Output:

*layer.TimeAttention
[[[1.1450074365793674e-19 1.4312592989939168e-19 1.7175111614084662e-19] [8 10 12]] [[2 2.5 3] [6 7.5 9]]]
[[[-5.038032728796514e-18 -6.2975409312678295e-18 -7.557049133739145e-18] [8 10 12]] [[2 2.5 3] [6 7.5 9]]]
[[[-5.152533472454451e-18 -6.4406668611672205e-18 -7.728800249879992e-18] [0 0 0]] [[-1.288133361247227e-18 -2.576266722494454e-18 -3.864400083741681e-18] [0 0 0]]]

func (*TimeAttention) Backward 

func (l *TimeAttention) Backward(dout []matrix.Matrix) ([]matrix.Matrix, []matrix.Matrix)

func (*TimeAttention) Forward 

func (l *TimeAttention) Forward(hsenc, hsdec []matrix.Matrix) []matrix.Matrix

func (*TimeAttention) Grads 

func (l *TimeAttention) Grads() []matrix.Matrix

func (*TimeAttention) Params 

func (l *TimeAttention) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	at := &layer.TimeAttention{}

	at.SetParams(matrix.New())
	fmt.Println(at.Params())
	fmt.Println(at.Grads())

}

Output:

[]
[]

func (*TimeAttention) ResetState 

func (l *TimeAttention) ResetState()

func (*TimeAttention) SetParams 

func (l *TimeAttention) SetParams(p ...matrix.Matrix)

func (*TimeAttention) SetState 

func (l *TimeAttention) SetState(_ ...matrix.Matrix)
Example 
package main

import (
	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	at := &layer.TimeAttention{}
	at.SetState(matrix.New())
	at.ResetState()

}

Output:

func (*TimeAttention) String 

func (l *TimeAttention) String() string

type TimeBiLSTM 

type TimeBiLSTM struct {
	F *TimeLSTM
	B *TimeLSTM
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	lstm := &layer.TimeBiLSTM{
		F: &layer.TimeLSTM{
			Wx: matrix.New(
				// (D, 4H) = (3, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			Wh: matrix.New(
				// (H, 4H) = (1, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			B: matrix.New(
				// (1, 4H) = (1, 4)
				[]float64{0, 0, 0, 0},
			),
		},
		B: &layer.TimeLSTM{
			Wx: matrix.New(
				// (D, 4H) = (3, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			Wh: matrix.New(
				// (H, 4H) = (1, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			B: matrix.New(
				// (1, 4H) = (1, 4)
				[]float64{0, 0, 0, 0},
			),
		},
	}

	for _, s := range lstm.Summary() {
		fmt.Println(s)
	}

	// forward
	xs := []matrix.Matrix{
		// (T, N, D) = (1, 2, 3)
		{
			// (N, D) = (2, 3)
			{0.1, 0.2, 0.3},
			{0.3, 0.4, 0.5},
		},
	}

	hs := lstm.Forward(xs, nil)
	for i := range hs {
		fmt.Print(hs[i].Dim()) // (N, 2H) = (2, 2)
		fmt.Println(":", hs[i])
	}

	// backward
	dhs := []matrix.Matrix{
		{
			// (N, 2H)
			{0.1, 0.2},
			{0.3, 0.4},
		},
	}
	dxs := lstm.Backward(dhs)
	for i := range dxs {
		fmt.Print(dxs[i].Dim()) // (T, N, D) = (1, 2, 3)
		fmt.Println(":", dxs[i])
	}

}

Output:

*layer.TimeBiLSTM
*layer.TimeLSTM: Wx(3, 4), Wh(1, 4), B(1, 4): 20
*layer.TimeLSTM: Wx(3, 4), Wh(1, 4), B(1, 4): 20
2 2: [[0.03637115410746597 0.03637115410746597] [0.08514639710269788 0.08514639710269788]]
2 3: [[0.021368657475674596 0.021368657475674596 0.021368657475674596] [0.06357173872462146 0.06357173872462146 0.06357173872462146]]

func (*TimeBiLSTM) Backward 

func (l *TimeBiLSTM) Backward(dhs []matrix.Matrix) []matrix.Matrix

func (*TimeBiLSTM) Forward 

func (l *TimeBiLSTM) Forward(xs, _ []matrix.Matrix, _ ...Opts) []matrix.Matrix

func (*TimeBiLSTM) Grads 

func (l *TimeBiLSTM) Grads() []matrix.Matrix

func (*TimeBiLSTM) Params 

func (l *TimeBiLSTM) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	lstm := &layer.TimeBiLSTM{
		F: &layer.TimeLSTM{
			Wx: matrix.New(
				// (D, 4H) = (3, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			Wh: matrix.New(
				// (H, 4H) = (1, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			B: matrix.New(
				// (1, 4H) = (1, 4)
				[]float64{0, 0, 0, 0},
			),
		},
		B: &layer.TimeLSTM{
			Wx: matrix.New(
				// (D, 4H) = (3, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			Wh: matrix.New(
				// (H, 4H) = (1, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			B: matrix.New(
				// (1, 4H) = (1, 4)
				[]float64{0, 0, 0, 0},
			),
		},
	}

	lstm.SetParams(make([]matrix.Matrix, 6)...)
	fmt.Println(lstm.Params())
	fmt.Println(lstm.Grads())

}

Output:

[[] [] [] [] [] []]
[[] [] [] [] [] []]

func (*TimeBiLSTM) ResetState 

func (l *TimeBiLSTM) ResetState()

func (*TimeBiLSTM) SetParams 

func (l *TimeBiLSTM) SetParams(p ...matrix.Matrix)

func (*TimeBiLSTM) SetState 

func (l *TimeBiLSTM) SetState(h ...matrix.Matrix)

SetState sets hidden state and cell state. SetState(hf, hb) or SetState(hf, cf, hb, cb)

Example 
package main

import (
	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	lstm := &layer.TimeBiLSTM{
		F: &layer.TimeLSTM{
			Wx: matrix.New(
				// (D, 4H) = (3, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			Wh: matrix.New(
				// (H, 4H) = (1, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			B: matrix.New(
				// (1, 4H) = (1, 4)
				[]float64{0, 0, 0, 0},
			),
			Stateful: false,
		},
		B: &layer.TimeLSTM{
			Wx: matrix.New(
				// (D, 4H) = (3, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			Wh: matrix.New(
				// (H, 4H) = (1, 4)
				[]float64{0.1, 0.2, 0.3, 0.4},
			),
			B: matrix.New(
				// (1, 4H) = (1, 4)
				[]float64{0, 0, 0, 0},
			),
			Stateful: false,
		},
	}
	lstm.SetState(matrix.New(), matrix.New())
	lstm.SetState(matrix.New(), matrix.New(), matrix.New(), matrix.New())
	lstm.ResetState()

}

Output:

func (*TimeBiLSTM) String 

func (l *TimeBiLSTM) String() string

func (*TimeBiLSTM) Summary 

func (l *TimeBiLSTM) Summary() []string

type TimeDropout 

type TimeDropout struct {
	Ratio float64
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
	"github.com/itsubaki/neu/math/rand"
)

func main() {
	xs := []matrix.Matrix{{{1.0, -0.5}, {-2.0, 3.0}}}
	s := rand.Const(1)

	drop := &layer.TimeDropout{}
	fmt.Println(drop)

	drop.Ratio = 0.0
	fmt.Println(drop.Forward(xs, nil, layer.Opts{Train: true, Source: s}))
	fmt.Println(drop.Backward(xs))
	fmt.Println(drop.Forward(xs, nil, layer.Opts{Train: false}))
	fmt.Println(drop.Backward(xs))
	fmt.Println()

	drop.Ratio = 0.5
	fmt.Println(drop.Forward(xs, nil, layer.Opts{Train: true, Source: s}))
	fmt.Println(drop.Backward(xs))
	fmt.Println(drop.Forward(xs, nil, layer.Opts{Train: false}))
	fmt.Println(drop.Backward(xs))

}

Output:

*layer.TimeDropout: Ratio(0)
[[[1 -0.5] [-2 3]]]
[[[1 -0.5] [-2 3]]]
[[[1 -0.5] [-2 3]]]
[[[1 -0.5] [-2 3]]]

[[[2 -1] [-0 0]]]
[[[2 -1] [-0 0]]]
[[[1 -0.5] [-2 3]]]
[[[2 -1] [-0 0]]]

func (*TimeDropout) Backward 

func (l *TimeDropout) Backward(dout []matrix.Matrix) []matrix.Matrix

func (*TimeDropout) Forward 

func (l *TimeDropout) Forward(xs, _ []matrix.Matrix, opts ...Opts) []matrix.Matrix

func (*TimeDropout) Grads 

func (l *TimeDropout) Grads() []matrix.Matrix

func (*TimeDropout) Params 

func (l *TimeDropout) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	drop := &layer.TimeDropout{Ratio: 0.5}

	drop.SetParams(make([]matrix.Matrix, 0)...)
	fmt.Println(drop.Params())
	fmt.Println(drop.Grads())

}

Output:

[]
[]

func (*TimeDropout) ResetState 

func (l *TimeDropout) ResetState()

func (*TimeDropout) SetParams 

func (l *TimeDropout) SetParams(p ...matrix.Matrix)

func (*TimeDropout) SetState 

func (l *TimeDropout) SetState(_ ...matrix.Matrix)
Example 
package main

import (
	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	dropout := &layer.TimeDropout{}
	dropout.SetState(matrix.New())
	dropout.ResetState()

}

Output:

func (*TimeDropout) String 

func (l *TimeDropout) String() string

type TimeEmbedding 

type TimeEmbedding struct {
	W  matrix.Matrix // params
	DW matrix.Matrix // grads
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	embed := &layer.TimeEmbedding{W: matrix.New(
		[]float64{0.0, 0.1, 0.2},
		[]float64{0.1, 0.2, 0.3},
		[]float64{0.2, 0.3, 0.4},
		[]float64{0.3, 0.4, 0.5},
		[]float64{0.4, 0.5, 0.6},
		[]float64{0.5, 0.6, 0.7},
	)}
	fmt.Println(embed)
	fmt.Println(embed.W)
	fmt.Println(embed.DW)
	fmt.Println()

	// forward
	xs := []matrix.Matrix{
		{
			{0},
			{2},
			{0},
			{4},
		},
	}
	fmt.Println(embed.Forward(xs, nil))

	// backward
	// p138
	dh := []matrix.Matrix{
		{
			{9.0, 9.1, 9.2},
			{9.1, 9.2, 9.3},
			{9.2, 9.3, 9.4},
			{9.3, 9.4, 9.5},
		},
	}

	embed.Backward(dh)
	fmt.Println(embed.DW)

}

Output:

*layer.TimeEmbedding: W(6, 3): 18
[[0 0.1 0.2] [0.1 0.2 0.3] [0.2 0.3 0.4] [0.3 0.4 0.5] [0.4 0.5 0.6] [0.5 0.6 0.7]]
[]

[[[0 0.1 0.2] [0.2 0.3 0.4] [0 0.1 0.2] [0.4 0.5 0.6]]]
[[18.2 18.4 18.6] [0 0 0] [9.1 9.2 9.3] [0 0 0] [9.3 9.4 9.5] [0 0 0]]

func (*TimeEmbedding) Backward 

func (l *TimeEmbedding) Backward(dout []matrix.Matrix) []matrix.Matrix

func (*TimeEmbedding) Forward 

func (l *TimeEmbedding) Forward(xs, _ []matrix.Matrix, _ ...Opts) []matrix.Matrix

func (*TimeEmbedding) Grads 

func (l *TimeEmbedding) Grads() []matrix.Matrix

func (*TimeEmbedding) Params 

func (l *TimeEmbedding) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	embed := &layer.TimeEmbedding{}

	embed.SetParams(make([]matrix.Matrix, 1)...)
	fmt.Println(embed.Params())
	fmt.Println(embed.Grads())

}

Output:

[[]]
[[]]

func (*TimeEmbedding) ResetState 

func (l *TimeEmbedding) ResetState()

func (*TimeEmbedding) SetParams 

func (l *TimeEmbedding) SetParams(p ...matrix.Matrix)

func (*TimeEmbedding) SetState 

func (l *TimeEmbedding) SetState(_ ...matrix.Matrix)
Example 
package main

import (
	"github.com/itsubaki/neu/layer"
)

func main() {
	embed := &layer.TimeEmbedding{}
	embed.SetState()
	embed.ResetState()

}

Output:

func (*TimeEmbedding) String 

func (l *TimeEmbedding) String() string

type TimeGRU 

type TimeGRU struct {
	Wx, Wh, B    matrix.Matrix // params
	DWx, DWh, DB matrix.Matrix // grads

	Stateful bool
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	// (D, H) = (3, 1)
	gru := &layer.TimeGRU{
		Wx: matrix.New(
			// (D, 3H) = (3, 3)
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
		),
		Wh: matrix.New(
			// (H, 3H) = (1, 3)
			[]float64{0.1, 0.2, 0.3},
		),
		B: matrix.New(
			// (1, 3H) = (1, 3)
			[]float64{0, 0, 0},
		),
	}
	fmt.Println(gru)

	// forward
	xs := []matrix.Matrix{
		// (T, N, D) = (1, 2, 3)
		{
			// (N, D) = (2, 3)
			{0.1, 0.2, 0.3},
			{0.3, 0.4, 0.5},
		},
	}

	hs := gru.Forward(xs, nil)
	for i := range hs {
		fmt.Print(hs[i].Dim()) // (N, H) = (2, 1)
		fmt.Println(":", hs[i])
	}

	// backward
	dhs := []matrix.Matrix{
		{
			// (N, H) = (2, 1)
			{0.1},
			{0.3},
		},
	}
	dxs := gru.Backward(dhs)
	for i := range dxs {
		fmt.Print(dxs[i].Dim()) // (T, N, D) = (1, 2, 3)
		fmt.Println(":", dxs[i])
	}

	fmt.Println(gru.DH())

}

Output:

*layer.TimeGRU: Wx(3, 3), Wh(1, 3), B(1, 3): 15
2 1: [[0.09171084600490446] [0.18295102825645382]]
2 3: [[0.019946542181883273 0.019946542181883273 0.019946542181883273] [0.05601681471011035 0.05601681471011035 0.05601681471011035]]
[[0.056873464301738536] [0.16710562310833357]]

func (*TimeGRU) Backward 

func (l *TimeGRU) Backward(dhs []matrix.Matrix) []matrix.Matrix

func (*TimeGRU) DH 

func (l *TimeGRU) DH() matrix.Matrix

func (*TimeGRU) Forward 

func (l *TimeGRU) Forward(xs, _ []matrix.Matrix, _ ...Opts) []matrix.Matrix

func (*TimeGRU) Grads 

func (l *TimeGRU) Grads() []matrix.Matrix

func (*TimeGRU) Params 

func (l *TimeGRU) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	gru := &layer.TimeGRU{}

	gru.SetParams(make([]matrix.Matrix, 3)...)
	fmt.Println(gru.Params())
	fmt.Println(gru.Grads())

}

Output:

[[] [] []]
[[] [] []]

func (*TimeGRU) ResetState 

func (l *TimeGRU) ResetState()

func (*TimeGRU) SetParams 

func (l *TimeGRU) SetParams(p ...matrix.Matrix)

func (*TimeGRU) SetState 

func (l *TimeGRU) SetState(h ...matrix.Matrix)
Example 
package main

import (
	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	gru := &layer.TimeGRU{}
	gru.SetState(matrix.New())
	gru.SetState(matrix.New(), matrix.New())
	gru.ResetState()

}

Output:

func (*TimeGRU) String 

func (l *TimeGRU) String() string

type TimeLSTM 

type TimeLSTM struct {
	Wx, Wh, B    matrix.Matrix // params
	DWx, DWh, DB matrix.Matrix // grads

	Stateful bool
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	// (D, H) = (3, 1)
	lstm := &layer.TimeLSTM{
		Wx: matrix.New(
			// (D, 4H) = (3, 4)
			[]float64{0.1, 0.2, 0.3, 0.4},
			[]float64{0.1, 0.2, 0.3, 0.4},
			[]float64{0.1, 0.2, 0.3, 0.4},
		),
		Wh: matrix.New(
			// (H, 4H) = (1, 4)
			[]float64{0.1, 0.2, 0.3, 0.4},
		),
		B: matrix.New(
			// (1, 4H) = (1, 4)
			[]float64{0, 0, 0, 0},
		),
	}
	fmt.Println(lstm)

	// forward
	xs := []matrix.Matrix{
		// (T, N, D) = (1, 2, 3)
		{
			// (N, D) = (2, 3)
			{0.1, 0.2, 0.3},
			{0.3, 0.4, 0.5},
		},
	}

	hs := lstm.Forward(xs, nil)
	for i := range hs {
		fmt.Print(hs[i].Dim()) // (N, H) = (2, 1)
		fmt.Println(":", hs[i])
	}

	// backward
	dhs := []matrix.Matrix{
		{
			// (N, H)
			{0.1},
			{0.3},
		},
	}
	dxs := lstm.Backward(dhs)
	for i := range dxs {
		fmt.Print(dxs[i].Dim()) // (T, N, D) = (1, 2, 3)
		fmt.Println(":", dxs[i])
	}

	fmt.Println(lstm.DH())

}

Output:

*layer.TimeLSTM: Wx(3, 4), Wh(1, 4), B(1, 4): 20
2 1: [[0.03637115410746597] [0.08514639710269788]]
2 3: [[0.007122885825224865 0.007122885825224865 0.007122885825224865] [0.027245030881980627 0.027245030881980627 0.027245030881980627]]
[[0.007122885825224865] [0.027245030881980627]]

func (*TimeLSTM) Backward 

func (l *TimeLSTM) Backward(dhs []matrix.Matrix) []matrix.Matrix

func (*TimeLSTM) DH 

func (l *TimeLSTM) DH() matrix.Matrix

func (*TimeLSTM) Forward 

func (l *TimeLSTM) Forward(xs, _ []matrix.Matrix, _ ...Opts) []matrix.Matrix

func (*TimeLSTM) Grads 

func (l *TimeLSTM) Grads() []matrix.Matrix

func (*TimeLSTM) Params 

func (l *TimeLSTM) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	lstm := &layer.TimeLSTM{}

	lstm.SetParams(make([]matrix.Matrix, 3)...)
	fmt.Println(lstm.Params())
	fmt.Println(lstm.Grads())

}

Output:

[[] [] []]
[[] [] []]

func (*TimeLSTM) ResetState 

func (l *TimeLSTM) ResetState()

func (*TimeLSTM) SetParams 

func (l *TimeLSTM) SetParams(p ...matrix.Matrix)

func (*TimeLSTM) SetState 

func (l *TimeLSTM) SetState(s ...matrix.Matrix)
Example 
package main

import (
	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	lstm := &layer.TimeLSTM{}
	lstm.SetState(matrix.New())
	lstm.SetState(matrix.New(), matrix.New())
	lstm.ResetState()

}

Output:

func (*TimeLSTM) String 

func (l *TimeLSTM) String() string

type TimeRNN 

type TimeRNN struct {
	Wx, Wh, B    matrix.Matrix // params
	DWx, DWh, DB matrix.Matrix // grads

	Stateful bool
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	rnn := &layer.TimeRNN{
		Wx: matrix.New(
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
		),
		Wh: matrix.New(
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
		),
		B: matrix.New(
			[]float64{0, 0, 0}),
	}
	fmt.Println(rnn)

	// forward
	xs := []matrix.Matrix{
		{
			{0.1, 0.2, 0.3},
			{0.3, 0.4, 0.5},
		},
	}

	hs := rnn.Forward(xs, nil)
	for i := range hs {
		fmt.Print(hs[i].Dim())
		fmt.Println(":", hs[i])
	}

	// backward
	dhs := []matrix.Matrix{
		{
			{0.1, 0.2, 0.3},
			{0.3, 0.4, 0.5},
		},
	}

	dxs := rnn.Backward(dhs)
	for i := range dxs {
		fmt.Print(dxs[i].Dim())
		fmt.Println(":", dxs[i])
	}
	fmt.Println()

	// grads
	for _, g := range rnn.Grads() {
		fmt.Println(g)
	}

}

Output:

*layer.TimeRNN: Wx(3, 3), Wh(3, 3), B(1, 3): 21
2 3: [[0.0599281035291435 0.1194272985343859 0.1780808681173302] [0.1194272985343859 0.23549574953849797 0.3452140341355209]]
2 3: [[0.13653941943561718 0.13653941943561718 0.13653941943561718] [0.23725954436226937 0.23725954436226937 0.23725954436226937]]

[[0.09868042705690408 0.1330597526412117 0.16117270672769926] [0.13821662689192143 0.19055616512647933 0.23426268639181055] [0.1777528267269388 0.24805257761174693 0.3073526660559219]]
[[0 0 0] [0 0 0] [0 0 0]]
[[0.3953619983501736 0.5749641248526761 0.730899796641113]]
Example (Time2) 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	rnn := &layer.TimeRNN{
		Wx: matrix.New(
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
		),
		Wh: matrix.New(
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
			[]float64{0.1, 0.2, 0.3},
		),
		B: matrix.New(
			[]float64{0, 0, 0},
		),
	}
	fmt.Println(rnn)
	fmt.Println()

	// forward
	xs := []matrix.Matrix{
		{
			{0.1, 0.2, 0.3},
			{0.3, 0.4, 0.5},
		},
		{
			{0.1, 0.2, 0.3},
			{0.3, 0.4, 0.5},
		},
	}

	hs := rnn.Forward(xs, nil)
	for i := range hs {
		fmt.Print(hs[i].Dim())
		fmt.Println(":", hs[i])
	}
	fmt.Println()

	// backward
	dhs := []matrix.Matrix{
		{
			{0.1, 0.2, 0.3},
			{0.3, 0.4, 0.5},
		},
		{
			{0.1, 0.2, 0.3},
			{0.3, 0.4, 0.5},
		},
	}

	dxs := rnn.Backward(dhs)
	for i := range dxs {
		fmt.Print(dxs[i].Dim())
		fmt.Println(":", dxs[i])
	}
	fmt.Println()

}

Output:

*layer.TimeRNN: Wx(3, 3), Wh(3, 3), B(1, 3): 21

2 3: [[0.0599281035291435 0.1194272985343859 0.1780808681173302] [0.1194272985343859 0.23549574953849797 0.3452140341355209]]
2 3: [[0.0954521402060995 0.1891806346377357 0.2795841294978488] [0.1877594308589768 0.3627312769661758 0.515389479517456]]

2 3: [[0.2137321004822292 0.2137321004822292 0.2137321004822292] [0.35233531505495563 0.35233531505495563 0.35233531505495563]]
2 3: [[0.131442260696387 0.131442260696387 0.131442260696387] [0.2085725262009533 0.2085725262009533 0.2085725262009533]]

func (*TimeRNN) Backward 

func (l *TimeRNN) Backward(dhs []matrix.Matrix) []matrix.Matrix

func (*TimeRNN) Forward 

func (l *TimeRNN) Forward(xs, _ []matrix.Matrix, _ ...Opts) []matrix.Matrix

func (*TimeRNN) Grads 

func (l *TimeRNN) Grads() []matrix.Matrix

func (*TimeRNN) Params 

func (l *TimeRNN) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	rnn := &layer.TimeRNN{}

	rnn.SetParams(make([]matrix.Matrix, 3)...)
	fmt.Println(rnn.Params())
	fmt.Println(rnn.Grads())

}

Output:

[[] [] []]
[[] [] []]

func (*TimeRNN) ResetState 

func (l *TimeRNN) ResetState()

func (*TimeRNN) SetParams 

func (l *TimeRNN) SetParams(p ...matrix.Matrix)

func (*TimeRNN) SetState 

func (l *TimeRNN) SetState(h ...matrix.Matrix)
Example 
package main

import (
	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	rnn := &layer.TimeRNN{}
	rnn.SetState(matrix.New())
	rnn.ResetState()

}

Output:

func (*TimeRNN) String 

func (l *TimeRNN) String() string

type TimeSoftmaxWithLoss 

type TimeSoftmaxWithLoss struct {
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	l := &layer.TimeSoftmaxWithLoss{}
	fmt.Println(l)

	// forward
	xs := []matrix.Matrix{
		{
			{0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0},
			{0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0},
		},
	}
	ts := []matrix.Matrix{
		{
			{2},
			{2},
		},
	}
	loss := l.Forward(xs, ts)
	fmt.Println(loss)

	// backward
	dout := []matrix.Matrix{{{1}}}
	dx := l.Backward(dout)
	for _, m := range dx {
		for _, r := range m {
			fmt.Println(r)
		}
	}

}

Output:

*layer.TimeSoftmaxWithLoss
[[[2.0694934853340516]]]
[0.04916164744936827 0.04676400561076958 -0.41894614614756587 0.044483298144480495 0.04676400561076958 0.04916164744936827 0.044483298144480495 0.04916164744936827 0.044483298144480495 0.044483298144480495]
[0.04916164744936827 0.04676400561076958 -0.45083835255063176 0.044483298144480495 0.04676400561076958 0.04916164744936827 0.044483298144480495 0.08105385385243416 0.044483298144480495 0.044483298144480495]

func (*TimeSoftmaxWithLoss) Backward 

func (l *TimeSoftmaxWithLoss) Backward(dout []matrix.Matrix) []matrix.Matrix

func (*TimeSoftmaxWithLoss) Forward 

func (l *TimeSoftmaxWithLoss) Forward(xs, ts []matrix.Matrix, _ ...Opts) []matrix.Matrix

func (*TimeSoftmaxWithLoss) Grads 

func (l *TimeSoftmaxWithLoss) Grads() []matrix.Matrix

func (*TimeSoftmaxWithLoss) Params 

func (l *TimeSoftmaxWithLoss) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	l := &layer.TimeSoftmaxWithLoss{}

	l.SetParams(make([]matrix.Matrix, 0)...)
	fmt.Println(l.Params())
	fmt.Println(l.Grads())

}

Output:

[]
[]

func (*TimeSoftmaxWithLoss) ResetState 

func (l *TimeSoftmaxWithLoss) ResetState()

func (*TimeSoftmaxWithLoss) SetParams 

func (l *TimeSoftmaxWithLoss) SetParams(p ...matrix.Matrix)

func (*TimeSoftmaxWithLoss) SetState 

func (l *TimeSoftmaxWithLoss) SetState(h ...matrix.Matrix)
Example 
package main

import (
	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	l := &layer.TimeSoftmaxWithLoss{}
	l.SetState(matrix.New())
	l.ResetState()

}

Output:

func (*TimeSoftmaxWithLoss) String 

func (l *TimeSoftmaxWithLoss) String() string

type UnigramSampler 

type UnigramSampler struct {
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/rand"
)

func main() {
	// p158
	corpus := []int{0, 1, 2, 3, 4, 1, 2, 3}
	power := 0.75
	sampleSize := 2
	sampler := layer.NewUnigramSampler(corpus, power, sampleSize)

	target := []int{1, 3, 0}
	for i, v := range sampler.NegativeSample(target, rand.Const(1)) {
		fmt.Printf("%v: %v\n", target[i], v)
	}

	for i, v := range sampler.NegativeSample(target) {
		fmt.Printf("%v: %v\n", target[i], len(v))
	}

}

Output:

1: [2 3]
3: [0 1]
0: [3 3]
1: 2
3: 2
0: 2

func NewUnigramSampler 

func NewUnigramSampler(corpus []int, power float64, size int) *UnigramSampler

func (*UnigramSampler) NegativeSample 

func (s *UnigramSampler) NegativeSample(target []int, seed ...randv2.Source) [][]int

type WeightSum 

type WeightSum struct {
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
	"github.com/itsubaki/neu/math/matrix"
)

func main() {
	ws := &layer.WeightSum{}
	fmt.Println(ws)

	// forward
	hs := []matrix.Matrix{
		// (T, N, H) (2, 2, 3)
		{
			{1, 2, 3},
			{4, 5, 6},
		},
		{
			{1, 2, 3},
			{4, 5, 6},
		},
	}
	a := matrix.Matrix{
		// (T, N) (2, 2)
		{2, 4},
		{2, 4},
	}
	fmt.Println(ws.Forward(hs, a))

	// backward
	dc := matrix.New(
		[]float64{1, 2, 3},
		[]float64{4, 5, 6},
	)
	dhs, da := ws.Backward(dc)
	fmt.Println(dhs)
	fmt.Println(da)

}

Output:

*layer.WeightSum
[[4 8 12] [32 40 48]]
[[[2 4 6] [16 20 24]] [[2 4 6] [16 20 24]]]
[[14 77] [14 77]]

func (*WeightSum) Backward 

func (l *WeightSum) Backward(dc matrix.Matrix) ([]matrix.Matrix, matrix.Matrix)

func (*WeightSum) Forward 

func (l *WeightSum) Forward(hs []matrix.Matrix, a matrix.Matrix) matrix.Matrix

func (*WeightSum) Grads 

func (l *WeightSum) Grads() []matrix.Matrix

func (*WeightSum) Params 

func (l *WeightSum) Params() []matrix.Matrix
Example 
package main

import (
	"fmt"

	"github.com/itsubaki/neu/layer"
)

func main() {
	ws := &layer.WeightSum{}

	ws.SetParams()
	fmt.Println(ws.Params())
	fmt.Println(ws.Grads())

}

Output:

[]
[]

func (*WeightSum) SetParams 

func (l *WeightSum) SetParams(p ...matrix.Matrix)

func (*WeightSum) String 

func (l *WeightSum) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.