function

package
v0.0.0-...-a3b61a5 Latest Latest
Warning

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

 Go to latest Published: May 5, 2024 License: MIT Imports: 5 Imported by: 0

Documentation

Overview

Example (Softmax1d) 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	softmax1d := func(x *variable.Variable) *variable.Variable {
		y := F.Exp(x)
		sumy := F.Sum(y)
		return F.Div(y, sumy)
	}

	x := variable.New(1, 2, 3)
	y := softmax1d(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x.Grad)

}

Output:

variable([0.09003057317038046 0.24472847105479767 0.6652409557748219])
variable([0 0 0])

Index

Examples

Constants

This section is empty.

Variables

View Source 
var (
	AddC        = variable.AddC
	Add         = variable.Add
	SubC        = variable.SubC
	Sub         = variable.Sub
	MulC        = variable.MulC
	Mul         = variable.Mul
	DivC        = variable.DivC
	Div         = variable.Div
	Sin         = variable.Sin
	Cos         = variable.Cos
	Tanh        = variable.Tanh
	Exp         = variable.Exp
	Log         = variable.Log
	Pow         = variable.Pow
	Square      = variable.Square
	Neg         = variable.Neg
	Sum         = variable.Sum
	SumTo       = variable.SumTo
	BroadcastTo = variable.BroadcastTo
	Reshape     = variable.Reshape
	Transpose   = variable.Transpose
	MatMul      = variable.MatMul
	Max         = variable.Max
	Min         = variable.Min
	Clip        = variable.Clip
	GetItem     = variable.GetItem
)

Functions

func Accuracy 

func Accuracy(y, t *variable.Variable) *variable.Variable

Accuracy returns the accuracy of the prediction. The return values cannot be backpropagated.

Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	// p391
	y := variable.NewOf(
		[]float64{0.2, 0.8, 0.0},
		[]float64{0.1, 0.9, 0.0},
		[]float64{0.8, 0.1, 0.1},
	)
	t := variable.New(1, 2, 0)

	fmt.Println(F.Accuracy(y, t))

}

Output:

variable([0.6666666666666666])

func DropoutSimple 

func DropoutSimple(ratio float64, s ...randv2.Source) func(x ...*variable.Variable) *variable.Variable
Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/rand"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	// p436
	x := variable.New(1, 1, 1, 1, 1)
	y := F.DropoutSimple(0.5, rand.Const())(x)
	fmt.Println(y)

	func() {
		defer variable.TestMode().End()

		y := F.DropoutSimple(0.5)(x)
		fmt.Println(y)
	}()

}

Output:

variable([2 2 0 0 0])
variable([1 1 1 1 1])
Example (Backward) 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/rand"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x := variable.New(0.1, 0.2, 0.3, 0.4, 0.5)
	y := F.DropoutSimple(0.5, rand.Const())(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x.Grad)

}

Output:

variable([0.2 0.4 0 0 0])
variable([2 2 0 0 0])

func Linear 

func Linear(x ...*variable.Variable) *variable.Variable
Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x := variable.NewOf(
		[]float64{1, 2, 3},
		[]float64{4, 5, 6},
	)
	w := variable.NewOf(
		[]float64{1, 2, 3, 4},
		[]float64{5, 6, 7, 8},
		[]float64{9, 10, 11, 12},
	)

	y := F.Linear(x, w)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x.Grad)
	fmt.Println(w.Grad)

}

Output:

variable([[38 44 50 56] [83 98 113 128]])
variable([[10 26 42] [10 26 42]])
variable([[5 5 5 5] [7 7 7 7] [9 9 9 9]])
Example (Bias) 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x := variable.NewOf(
		[]float64{1, 2, 3},
		[]float64{4, 5, 6},
	)
	w := variable.NewOf(
		[]float64{1, 2, 3, 4},
		[]float64{5, 6, 7, 8},
		[]float64{9, 10, 11, 12},
	)
	b := variable.New(1.0)

	y := F.Linear(x, w, b)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x.Grad)
	fmt.Println(w.Grad)
	fmt.Println(b.Grad)

}

Output:

variable([[39 45 51 57] [84 99 114 129]])
variable([[10 26 42] [10 26 42]])
variable([[5 5 5 5] [7 7 7 7] [9 9 9 9]])
variable([8])

func LinearSimple 

func LinearSimple(x, w *variable.Variable, b ...*variable.Variable) *variable.Variable
Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x := variable.NewOf(
		[]float64{1, 2, 3},
		[]float64{4, 5, 6},
	)
	w := variable.NewOf(
		[]float64{1, 2, 3, 4},
		[]float64{5, 6, 7, 8},
		[]float64{9, 10, 11, 12},
	)

	y := F.LinearSimple(x, w)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x.Grad)
	fmt.Println(w.Grad)

}

Output:

variable([[38 44 50 56] [83 98 113 128]])
variable([[10 26 42] [10 26 42]])
variable([[5 5 5 5] [7 7 7 7] [9 9 9 9]])
Example (Bias) 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x := variable.NewOf(
		[]float64{1, 2, 3},
		[]float64{4, 5, 6},
	)
	w := variable.NewOf(
		[]float64{1, 2, 3, 4},
		[]float64{5, 6, 7, 8},
		[]float64{9, 10, 11, 12},
	)
	b := variable.New(1.0)

	y := F.LinearSimple(x, w, b)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x.Grad)
	fmt.Println(w.Grad)
	fmt.Println(b.Grad)

}

Output:

variable([[39 45 51 57] [84 99 114 129]])
variable([[10 26 42] [10 26 42]])
variable([[5 5 5 5] [7 7 7 7] [9 9 9 9]])
variable([8])

func MeanSquaredError 

func MeanSquaredError(x ...*variable.Variable) *variable.Variable
Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x0 := variable.NewOf(
		[]float64{1, 2, 3},
		[]float64{1, 2, 3},
	)
	x1 := variable.NewOf(
		[]float64{3, 4, 5},
		[]float64{3, 4, 5},
	)

	y := F.MeanSquaredError(x0, x1)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x0.Grad)
	fmt.Println(x1.Grad)

}

Output:

variable([12])
variable([[-2 -2 -2] [-2 -2 -2]])
variable([[2 2 2] [2 2 2]])

func MeanSquaredErrorSimple 

func MeanSquaredErrorSimple(x0, x1 *variable.Variable) *variable.Variable
Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x0 := variable.NewOf(
		[]float64{1, 2, 3},
		[]float64{1, 2, 3},
	)
	x1 := variable.NewOf(
		[]float64{3, 4, 5},
		[]float64{3, 4, 5},
	)

	y := F.MeanSquaredErrorSimple(x0, x1)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x0.Grad)
	fmt.Println(x1.Grad)

}

Output:

variable([12])
variable([[-2 -2 -2] [-2 -2 -2]])
variable([[2 2 2] [2 2 2]])

func ReLU 

func ReLU(x ...*variable.Variable) *variable.Variable
Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x := variable.NewOf(
		[]float64{1, -2, 3},
		[]float64{-4, 5, -6},
	)

	y := F.ReLU(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x.Grad)

}

Output:

variable([[1 0 3] [0 5 0]])
variable([[1 0 1] [0 1 0]])

func Sigmoid 

func Sigmoid(x ...*variable.Variable) *variable.Variable
Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	// p330
	fmt.Println(F.Sigmoid(variable.New(-4)))
	fmt.Println(F.Sigmoid(variable.New(-2)))
	fmt.Println(F.Sigmoid(variable.New(0.0)))
	fmt.Println(F.Sigmoid(variable.New(2)))
	fmt.Println(F.Sigmoid(variable.New(4)))

}

Output:

variable([0.01798620996209155])
variable([0.11920292202211757])
variable([0.5])
variable([0.8807970779778824])
variable([0.9820137900379085])
Example (Backward) 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x := variable.New(-4, 2, 0, 2, 4)
	y := F.Sigmoid(x)
	y.Backward()

	fmt.Println(x.Grad)

}

Output:

variable([0.017662706213291107 0.10499358540350653 0.25 0.10499358540350653 0.017662706213291107])

func SigmoidSimple 

func SigmoidSimple(x *variable.Variable) *variable.Variable
Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	// p330
	fmt.Println(F.SigmoidSimple(variable.New(-4)))
	fmt.Println(F.SigmoidSimple(variable.New(-2)))
	fmt.Println(F.SigmoidSimple(variable.New(0.0)))
	fmt.Println(F.SigmoidSimple(variable.New(2)))
	fmt.Println(F.SigmoidSimple(variable.New(4)))

}

Output:

variable([0.01798620996209156])
variable([0.11920292202211755])
variable([0.5])
variable([0.8807970779778823])
variable([0.9820137900379085])
Example (Backward) 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	for _, v := range []float64{-4, 2, 0, 2, 4} {
		x := variable.New(v)
		y := F.SigmoidSimple(x)
		y.Backward()

		fmt.Println(x.Grad)
	}

}

Output:

variable([0.017662706213291118])
variable([0.1049935854035065])
variable([0.25])
variable([0.1049935854035065])
variable([0.017662706213291114])

func Softmax 

func Softmax(x ...*variable.Variable) *variable.Variable
Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x := variable.NewOf(
		[]float64{1, 2, 3},
		[]float64{4, 4, 8},
	)

	y := F.Softmax(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x.Grad)

}

Output:

variable([[0.09003057317038046 0.24472847105479764 0.6652409557748218] [0.017668422014048047 0.017668422014048047 0.9646631559719038]])
variable([[1.3877787807814457e-17 2.7755575615628914e-17 1.1102230246251565e-16] [3.469446951953614e-18 3.469446951953614e-18 1.1102230246251565e-16]])

func SoftmaxCrossEntropy 

func SoftmaxCrossEntropy(x ...*variable.Variable) *variable.Variable
Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x := variable.NewOf(
		[]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 := variable.New(2, 2)

	y := F.SoftmaxCrossEntropy(x, t)
	y.Backward()

	fmt.Println(y)
	for _, v := range x.Grad.Data {
		fmt.Printf("%.8f\n", v)
	}

}

Output:

variable([2.069494302297095])
[0.04916165 0.04676401 -0.41894615 0.04448330 0.04676401 0.04916165 0.04448330 0.04916165 0.04448330 0.04448330]
[0.04916165 0.04676401 -0.45083835 0.04448330 0.04676401 0.04916165 0.04448330 0.08105385 0.04448330 0.04448330]

func SoftmaxSimple 

func SoftmaxSimple(x *variable.Variable) *variable.Variable
Example 
package main

import (
	"fmt"

	F "github.com/itsubaki/autograd/function"
	"github.com/itsubaki/autograd/variable"
)

func main() {
	x := variable.NewOf(
		[]float64{1, 2, 3},
		[]float64{4, 4, 8},
	)

	y := F.SoftmaxSimple(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x.Grad)

}

Output:

variable([[0.09003057317038046 0.24472847105479767 0.6652409557748219] [0.017668422014048047 0.017668422014048047 0.9646631559719039]])
variable([[0 0 0] [0 0 0]])

Types

type LinearT 

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

func (*LinearT) Backward 

func (f *LinearT) Backward(gy ...*variable.Variable) []*variable.Variable

func (*LinearT) Forward 

func (f *LinearT) Forward(x ...*variable.Variable) []*variable.Variable

type MeanSquaredErrorT 

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

func (*MeanSquaredErrorT) Backward 

func (f *MeanSquaredErrorT) Backward(gy ...*variable.Variable) []*variable.Variable

func (*MeanSquaredErrorT) Forward 

func (f *MeanSquaredErrorT) Forward(x ...*variable.Variable) []*variable.Variable

type ReLUT 

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

func (*ReLUT) Backward 

func (f *ReLUT) Backward(gy ...*variable.Variable) []*variable.Variable

func (*ReLUT) Forward 

func (f *ReLUT) Forward(x ...*variable.Variable) []*variable.Variable

type SigmoidT 

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

func (*SigmoidT) Backward 

func (f *SigmoidT) Backward(gy ...*variable.Variable) []*variable.Variable

func (*SigmoidT) Forward 

func (f *SigmoidT) Forward(x ...*variable.Variable) []*variable.Variable

type SoftmaxCrossEntropyT 

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

func (*SoftmaxCrossEntropyT) Backward 

func (f *SoftmaxCrossEntropyT) Backward(gy ...*variable.Variable) []*variable.Variable

func (*SoftmaxCrossEntropyT) Forward 

func (f *SoftmaxCrossEntropyT) Forward(x ...*variable.Variable) []*variable.Variable

type SoftmaxT 

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

func (*SoftmaxT) Backward 

func (f *SoftmaxT) Backward(gy ...*variable.Variable) []*variable.Variable

func (*SoftmaxT) Forward 

func (f *SoftmaxT) Forward(x ...*variable.Variable) []*variable.Variable

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.