variable

package
v0.0.6 Latest Latest
Warning

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

 Go to latest Published: Dec 26, 2025 License: MIT Imports: 4 Imported by: 3

Documentation

Overview

Example (Add) 
package main

import (
	"fmt"

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

func main() {
	fmt.Println(variable.AddGrad(nil, variable.New(1)))
	fmt.Println(variable.AddGrad(variable.New(1), variable.New(2)))

}

Output:

variable(1)
variable(3)
Example (Retaingrad) 
package main

import (
	"fmt"

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

func main() {
	// p121
	x0 := variable.New(1.0)
	x1 := variable.New(1.0)
	t := variable.Add(x0, x1)
	y := variable.Add(x0, t)
	y.Backward(variable.Opts{RetainGrad: true})

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

}

Output:

variable(1) variable(1)
variable(2) variable(1)
Example (Retaingrad_false) 
package main

import (
	"fmt"

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

func main() {
	// p123
	x0 := variable.New(1.0)
	x1 := variable.New(1.0)
	t := variable.Add(x0, x1)
	y := variable.Add(x0, t)
	y.Backward()

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

}

Output:

<nil> <nil>
variable(2) variable(1)
Example (Tanh) 
package main

import (
	"fmt"

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

func main() {
	// p249
	x := variable.New(1.0)

	y := variable.Tanh(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(x.Grad)

	gx = x.Grad
	x.Cleargrad()
	gx.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(x.Grad)

	gx = x.Grad
	x.Cleargrad()
	gx.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(x.Grad)

	// 1-tanh(1)^2                                   =  0.41997434161
	// −2*tanh(1)*(1−tanh^2(1))                      = -0.63970000844
	// 4*tanh^2(1)*sech^2(1) - 2*sech^4(1)           =  0.62162668077
	// 16*tanh(1) *sech^4(1) - 8*tanh^3(1)*sech^2(1) =  0.66509104475

}

Output:

variable(0.41997434161402614)
variable(-0.6397000084492246)
variable(0.6216266807712962)
variable(0.6650910447505024)
Example (Zip) 
package main

import (
	"fmt"

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

func main() {
	xs := []*variable.Variable{
		variable.New(1),
		variable.New(2),
	}
	gxs := []*variable.Variable{
		variable.New(1),
	}
	xs, gxs = variable.Zip(xs, gxs)
	fmt.Println(len(xs), len(gxs))

}

Output:

1 1

Index

Examples

Constants

This section is empty.

Variables

View Source 
var Config = config{
	EnableBackprop: true,
	Train:          true,
}

Functions

func BroadcastTo 

func BroadcastTo(shape ...int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(2)
	y := variable.BroadcastTo(1, 3)(x)
	y.Backward()

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

}

Output:

variable[1 3]([2 2 2])
variable(3)
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(2)

	y := variable.BroadcastTo(1, 3)(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable[1 3]([2 2 2])
variable(3)
<nil>

func Clip 

func Clip(min, max float64) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(-2, -1, 0, 1, 2, 4, 6, 8)
	y := variable.Clip(0, 5)(x)
	y.Backward()

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

}

Output:

variable[8]([0 0 0 1 2 4 5 5])
variable[8]([0 0 1 1 1 1 0 0])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(-2, -1, 0, 1, 2, 4, 6, 8)

	y := variable.Clip(0, 5)(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable[8]([0 0 0 1 2 4 5 5])
variable[8]([0 0 1 1 1 1 0 0])
<nil>

func Concat added in v0.0.2 

func Concat(axis int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.New(
		7, 8,
		9, 10,
	).Reshape(2, 2)

	axis := 1
	z := variable.Concat(axis)(x, y)
	z.Backward()

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

}

Output:

variable[2 5]([1 2 3 7 8 4 5 6 9 10])
variable[2 3]([1 1 1 1 1 1])
variable[2 2]([1 1 1 1])
Example (Axis0) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.New(
		7, 8, 9,
	).Reshape(1, 3)

	axis := 0
	z := variable.Concat(axis)(x, y)
	z.Backward()

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

}

Output:

variable[3 3]([1 2 3 4 5 6 7 8 9])
variable[2 3]([1 1 1 1 1 1])
variable[1 3]([1 1 1])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.New(
		7, 8,
		9, 10,
	).Reshape(2, 2)

	axis := 1
	z := variable.Concat(axis)(x, y)
	z.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(z)
	fmt.Println(x.Grad)
	fmt.Println(y.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable[2 5]([1 2 3 7 8 4 5 6 9 10])
variable[2 3]([1 1 1 1 1 1])
variable[2 2]([1 1 1 1])
<nil>

func GetItem 

func GetItem(indices []int, axis int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	// p361
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.GetItem([]int{1}, 0)(x)
	y.Backward()

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

}

Output:

variable[1 3]([4 5 6])
variable[2 3]([0 0 0 1 1 1])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.GetItem([]int{1}, 0)(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable[1 3]([4 5 6])
variable[2 3]([0 0 0 1 1 1])
<nil>
Example (Indices) 
package main

import (
	"fmt"

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

func main() {
	// p363
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.GetItem([]int{0, 0, 1}, 0)(x)
	y.Backward()

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

}

Output:

variable[3 3]([1 2 3 1 2 3 4 5 6])
variable[2 3]([2 2 2 1 1 1])

func GetItemGrad 

func GetItemGrad(indices, shape []int, axis int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	gy := variable.New(
		1, 1, 1,
		1, 1, 1,
		1, 1, 1,
	).Reshape(3, 3)

	y := variable.GetItemGrad([]int{0, 0, 1}, []int{2, 3}, 0)(gy)
	y.Backward()

	fmt.Println(y)
	fmt.Println(gy.Grad)

}

Output:

variable[2 3]([2 2 2 1 1 1])
variable[3 3]([1 1 1 1 1 1 1 1 1])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	gy := variable.New(
		1, 1, 1,
		1, 1, 1,
		1, 1, 1,
	).Reshape(3, 3)

	y := variable.GetItemGrad([]int{0, 0, 1}, []int{2, 3}, 0)(gy)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(gy.Grad)

	ggy := gy.Grad
	gy.Cleargrad()
	ggy.Backward()
	fmt.Println(gy.Grad)

}

Output:

variable[2 3]([2 2 2 1 1 1])
variable[3 3]([1 1 1 1 1 1 1 1 1])
<nil>

func HasCreateGraph 

func HasCreateGraph(opts ...Opts) bool
Example 
package main

import (
	"fmt"

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

func main() {
	fmt.Println(variable.HasCreateGraph())
	fmt.Println(variable.HasCreateGraph(variable.Opts{CreateGraph: false}))
	fmt.Println(variable.HasCreateGraph(variable.Opts{CreateGraph: true}))

}

Output:

false
false
true

func HasRetainGrad 

func HasRetainGrad(opts ...Opts) bool
Example 
package main

import (
	"fmt"

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

func main() {
	fmt.Println(variable.HasRetainGrad())
	fmt.Println(variable.HasRetainGrad(variable.Opts{RetainGrad: false}))
	fmt.Println(variable.HasRetainGrad(variable.Opts{RetainGrad: true}))

}

Output:

false
false
true

func Max 

func Max(axes ...int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 10, 6,
	).Reshape(2, 3)

	y := variable.Max()(x)
	y.Backward()

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

}

Output:

variable(10)
variable[2 3]([0 0 0 0 1 0])
Example (Axis0) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 10, 6,
	).Reshape(2, 3)

	y := variable.Max(0)(x)
	y.Backward()

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

}

Output:

variable[3]([4 10 6])
variable[2 3]([0 0 0 1 1 1])
Example (Axis01) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 10, 6,
	).Reshape(2, 3)

	y := variable.Max(0, 1)(x)
	y.Backward()

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

}

Output:

variable(10)
variable[2 3]([0 0 0 0 1 0])
Example (Axis1) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 10, 6,
	).Reshape(2, 3)

	y := variable.Max(1)(x)
	y.Backward()

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

}

Output:

variable[2]([3 10])
variable[2 3]([0 0 1 0 1 0])
Example (Axis21n) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 10, 6,
	).Reshape(2, 3)

	y := variable.Max(-2, -1)(x)
	y.Backward()

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

}

Output:

variable(10)
variable[2 3]([0 0 0 0 1 0])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 10, 6,
	).Reshape(2, 3)

	y := variable.Max()(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable(10)
variable[2 3]([0 0 0 0 1 0])
<nil>

func Mean added in v0.0.2 

func Mean(axes ...int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Mean()(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(variable.Clip(0, 0.1666)(x.Grad))

}

Output:

variable(3.5)
variable[2 3]([0.1666 0.1666 0.1666 0.1666 0.1666 0.1666])
Example (Axis0) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Mean(0)(x)
	y.Backward()

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

}

Output:

variable[3]([2.5 3.5 4.5])
variable[2 3]([0.5 0.5 0.5 0.5 0.5 0.5])
Example (Axis01) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Mean(0, 1)(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(variable.Clip(0, 0.1666)(x.Grad))

}

Output:

variable(3.5)
variable[2 3]([0.1666 0.1666 0.1666 0.1666 0.1666 0.1666])
Example (Axis1) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Mean(1)(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(variable.Clip(0, 0.3333)(x.Grad))

}

Output:

variable[2]([2 5])
variable[2 3]([0.3333 0.3333 0.3333 0.3333 0.3333 0.3333])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Mean(0, 1)(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable(3.5)
<nil>

func Min 

func Min(axes ...int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, -5, 6,
	).Reshape(2, 3)

	y := variable.Min()(x)
	y.Backward()

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

}

Output:

variable(-5)
variable[2 3]([0 0 0 0 1 0])
Example (Axis0) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, -5, 6,
	).Reshape(2, 3)

	y := variable.Min(0)(x)
	y.Backward()

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

}

Output:

variable[3]([1 -5 3])
variable[2 3]([1 0 1 0 1 0])
Example (Axis01) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, -5, 6,
	).Reshape(2, 3)

	y := variable.Min(0, 1)(x)
	y.Backward()

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

}

Output:

variable(-5)
variable[2 3]([0 0 0 0 1 0])
Example (Axis1) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, -5, 6,
	).Reshape(2, 3)

	y := variable.Min(1)(x)
	y.Backward()

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

}

Output:

variable[2]([1 -5])
variable[2 3]([1 0 0 0 1 0])
Example (Axis21n) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, -5, 6,
	).Reshape(2, 3)

	y := variable.Min(-2, -1)(x)
	y.Backward()

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

}

Output:

variable(-5)
variable[2 3]([0 0 0 0 1 0])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, -5, 6,
	).Reshape(2, 3)

	y := variable.Min()(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable(-5)
variable[2 3]([0 0 0 0 1 0])
<nil>

func NoCreateGraph 

func NoCreateGraph(opts ...Opts) bool
Example 
package main

import (
	"fmt"

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

func main() {
	fmt.Println(variable.NoCreateGraph())
	fmt.Println(variable.NoCreateGraph(variable.Opts{CreateGraph: false}))
	fmt.Println(variable.NoCreateGraph(variable.Opts{CreateGraph: true}))

}

Output:

true
true
false

func NoRetainGrad 

func NoRetainGrad(opts ...Opts) bool
Example 
package main

import (
	"fmt"

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

func main() {
	fmt.Println(variable.NoRetainGrad())
	fmt.Println(variable.NoRetainGrad(variable.Opts{RetainGrad: false}))
	fmt.Println(variable.NoRetainGrad(variable.Opts{RetainGrad: true}))

}

Output:

true
true
false

func Pow 

func Pow(p float64) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(2.0)
	y := variable.Pow(3.0)(x)
	y.Backward()

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

}

Output:

variable(8)
variable(12)
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(2.0)

	y := variable.Pow(3.0)(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	for range 3 {
		gx := x.Grad
		x.Cleargrad()
		gx.Backward(variable.Opts{CreateGraph: true})
		fmt.Println(x.Grad)
	}

}

Output:

variable(8)
variable(12)
variable(12)
variable(6)
variable(0)

func Reshape 

func Reshape(shape ...int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	// p282
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Reshape(1, 6)(x)
	y.Backward(variable.Opts{RetainGrad: true})

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

}

Output:

variable[2 3]([1 2 3 4 5 6])
variable[1 6]([1 2 3 4 5 6])
variable[2 3]([1 1 1 1 1 1])
variable[1 6]([1 1 1 1 1 1])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	// p282
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Reshape(1, 6)(x)
	y.Backward(variable.Opts{CreateGraph: true, RetainGrad: true})
	fmt.Println(x)
	fmt.Println(y)
	fmt.Println(x.Grad)
	fmt.Println(y.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable[2 3]([1 2 3 4 5 6])
variable[1 6]([1 2 3 4 5 6])
variable[2 3]([1 1 1 1 1 1])
variable[1 6]([1 1 1 1 1 1])
<nil>

func Split added in v0.0.2 

func Split(size []int, axis int) func(x ...*Variable) []*Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
		7, 8, 9,
	).Reshape(3, 3)

	y := variable.Split([]int{1, 2}, 0)(x)
	fmt.Println(y[0])
	fmt.Println(y[1])

	y[0].Backward()
	fmt.Println(x.Grad)

}

Output:

variable[1 3]([1 2 3])
variable[2 3]([4 5 6 7 8 9])
variable[3 3]([1 1 1 0 0 0 0 0 0])
Example (Axis1) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
		7, 8, 9,
	).Reshape(3, 3)

	y := variable.Split([]int{1, 2}, 1)(x)
	fmt.Println(y[0])
	fmt.Println(y[1])

	y[0].Backward()
	fmt.Println(x.Grad)

}

Output:

variable[3 1]([1 4 7])
variable[3 2]([2 3 5 6 8 9])
variable[3 3]([1 0 0 1 0 0 1 0 0])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
		7, 8, 9,
	).Reshape(3, 3)

	y := variable.Split([]int{1, 2}, 0)(x)
	fmt.Println(y[0])
	fmt.Println(y[1])

	y[0].Backward(variable.Opts{CreateGraph: true})
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(gx.Grad)

}

Output:

variable[1 3]([1 2 3])
variable[2 3]([4 5 6 7 8 9])
variable[3 3]([1 1 1 0 0 0 0 0 0])
<nil>
Example (Y01) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
		7, 8, 9,
	).Reshape(3, 3)

	y := variable.Split([]int{1, 2}, 0)(x)
	fmt.Println(y[0])
	fmt.Println(y[1])

	y[0].Backward()
	y[1].Backward()
	fmt.Println(x.Grad)

}

Output:

variable[1 3]([1 2 3])
variable[2 3]([4 5 6 7 8 9])
variable[3 3]([1 1 1 1 1 1 1 1 1])
Example (Y1) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
		7, 8, 9,
	).Reshape(3, 3)

	y := variable.Split([]int{1, 2}, 0)(x)
	fmt.Println(y[0])
	fmt.Println(y[1])

	y[1].Backward()
	fmt.Println(x.Grad)

}

Output:

variable[1 3]([1 2 3])
variable[2 3]([4 5 6 7 8 9])
variable[3 3]([0 0 0 1 1 1 1 1 1])

func Sum 

func Sum(axes ...int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	// p292
	x := variable.New(1, 2, 3, 4, 5, 6)
	y := variable.Sum()(x)
	y.Backward()

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

}

Output:

variable(21)
variable[6]([1 1 1 1 1 1])
Example (Axis0) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Sum(0)(x)
	y.Backward()

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

}

Output:

variable[3]([5 7 9])
variable[2 3]([1 1 1 1 1 1])
Example (Axis01) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Sum(0, 1)(x)
	y.Backward()

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

}

Output:

variable(21)
variable[2 3]([1 1 1 1 1 1])
Example (Axis1) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Sum(1)(x)
	y.Backward()

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

}

Output:

variable[2]([6 15])
variable[2 3]([1 1 1 1 1 1])
Example (Axis21n) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Sum(-2, -1)(x)
	y.Backward()

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

}

Output:

variable(21)
variable[2 3]([1 1 1 1 1 1])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(1, 2, 3, 4, 5, 6)

	y := variable.Sum()(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable(21)
variable[6]([1 1 1 1 1 1])
<nil>

func SumTo 

func SumTo(shape ...int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	// p301
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.SumTo(1, 3)(x)
	y.Backward()

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

}

Output:

variable[1 3]([5 7 9])
variable[2 3]([1 1 1 1 1 1])
Example (Axes11) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.SumTo(1, 1)(x)
	y.Backward()

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

}

Output:

variable(21)
variable[2 3]([1 1 1 1 1 1])
Example (Axes21) 
package main

import (
	"fmt"

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

func main() {
	// p301
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.SumTo(2, 1)(x)
	y.Backward()

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

}

Output:

variable[2 1]([6 15])
variable[2 3]([1 1 1 1 1 1])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.SumTo(1, 3)(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable[1 3]([5 7 9])
variable[2 3]([1 1 1 1 1 1])
<nil>

func Transpose 

func Transpose(axes ...int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	// p286
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Transpose(-1, -2)(x)
	y.Backward()

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

}

Output:

variable[3 2]([1 4 2 5 3 6])
variable[2 3]([1 1 1 1 1 1])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	// p286
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Transpose(-1, -2)(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable[3 2]([1 4 2 5 3 6])
variable[2 3]([1 1 1 1 1 1])
<nil>

func TransposeMatMul added in v0.0.2 

func TransposeMatMul(ndim int) func(x ...*Variable) *Variable

TransposeMatMul returns a function that transposes a tensor by swapping the last two axes, which is often required when preparing inputs for MatMul.

The permutation of axes is automatically constructed based on ndim. For example, if ndim = 4, the axes will be [0, 1, 3, 2], so the last two dimensions are reversed while the others remain in order.

func Variance added in v0.0.2 

func Variance(axes ...int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		-1, 0, 1,
		-1, 0, 1,
	).Reshape(2, 3)

	y := variable.Variance()(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(variable.Clip(-0.333, 0.333)(x.Grad))

}

Output:

variable(0.6666666666666666)
variable[2 3]([-0.333 0 0.333 -0.333 0 0.333])
Example (Axis0) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	y := variable.Variance(0)(x)
	y.Backward()

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

}

Output:

variable[3]([2.25 2.25 2.25])
variable[2 3]([-1.5 -1.5 -1.5 1.5 1.5 1.5])
Example (Axis01) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		-1, 0, 1,
		-1, 0, 1,
	).Reshape(2, 3)

	y := variable.Variance(0, 1)(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(variable.Clip(-0.333, 0.333)(x.Grad))

}

Output:

variable(0.6666666666666666)
variable[2 3]([-0.333 0 0.333 -0.333 0 0.333])
Example (Axis1) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		-3, 0, 3,
		-3, 0, 3,
	).Reshape(2, 3)

	y := variable.Variance(1)(x)
	y.Backward()

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

}

Output:

variable[2]([6 6])
variable[2 3]([-2 0 2 -2 0 2])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		-3, 0, 3,
		-3, 0, 3,
	).Reshape(2, 3)

	y := variable.Variance(1)(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad) // NOTE: zeros..., why?

}

Output:

variable[2]([6 6])
variable[2 3]([-2 0 2 -2 0 2])
variable[2 3]([0 0 0 0 0 0])

Types

type AddT 

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

import (
	"fmt"

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

func main() {
	a := variable.New(2, 3)
	b := variable.New(3, 4)
	f := variable.AddT{}

	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(f.Forward(a, b))
	fmt.Println(f.Backward(variable.OneLike(a), variable.OneLike(b)))

}

Output:

variable[2]([2 3])
variable[2]([3 4])
[variable[2]([5 7])]
[variable[2]([1 1]) variable[2]([1 1])]

func (*AddT) Backward 

func (f *AddT) Backward(gy ...*Variable) []*Variable

func (*AddT) Forward 

func (f *AddT) Forward(x ...*Variable) []*Variable

type BroadcastToT 

type BroadcastToT struct {
	Shape []int
	// contains filtered or unexported fields
}

func (*BroadcastToT) Backward 

func (f *BroadcastToT) Backward(gy ...*Variable) []*Variable

func (*BroadcastToT) Forward 

func (f *BroadcastToT) Forward(x ...*Variable) []*Variable

type ClipT 

type ClipT struct {
	Min, Max float64
	// contains filtered or unexported fields
}

func (*ClipT) Backward 

func (f *ClipT) Backward(gy ...*Variable) []*Variable

func (*ClipT) Forward 

func (f *ClipT) Forward(x ...*Variable) []*Variable

type ConcatT added in v0.0.2 

type ConcatT struct {
	Axis int
	// contains filtered or unexported fields
}

func (*ConcatT) Backward added in v0.0.2 

func (f *ConcatT) Backward(gy ...*Variable) []*Variable

func (*ConcatT) Forward added in v0.0.2 

func (f *ConcatT) Forward(x ...*Variable) []*Variable

type CosT 

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

import (
	"fmt"
	"math"

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

func main() {
	x := variable.New(math.Pi / 4)
	f := variable.CosT{}

	fmt.Println(x)
	fmt.Println(f.Forward(x))
	fmt.Println(f.Backward(variable.OneLike(x)))

}

Output:

variable(0.7853981633974483)
[variable(0.7071067811865476)]
[variable(-0.7071067811865475)]

func (*CosT) Backward 

func (f *CosT) Backward(gy ...*Variable) []*Variable

func (*CosT) Forward 

func (f *CosT) Forward(x ...*Variable) []*Variable

type DivT 

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

func (*DivT) Backward 

func (f *DivT) Backward(gy ...*Variable) []*Variable

func (*DivT) Forward 

func (f *DivT) Forward(x ...*Variable) []*Variable

type ExpT 

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

import (
	"fmt"

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

func main() {
	x := variable.New(1, 2, 3, 4, 5)
	f := variable.ExpT{}

	fmt.Println(x)
	fmt.Println(f.Forward(x))
	fmt.Println(f.Backward(variable.OneLike(x)))

}

Output:

variable[5]([1 2 3 4 5])
[variable[5]([2.718281828459045 7.38905609893065 20.085536923187668 54.598150033144236 148.4131591025766])]
[variable[5]([2.718281828459045 7.38905609893065 20.085536923187668 54.598150033144236 148.4131591025766])]

func (*ExpT) Backward 

func (f *ExpT) Backward(gy ...*Variable) []*Variable

func (*ExpT) Forward 

func (f *ExpT) Forward(x ...*Variable) []*Variable

type Forwarder 

type Forwarder interface {
	Forward(x ...*Variable) []*Variable
	Backward(gy ...*Variable) []*Variable
}

type Function 

type Function struct {
	Input, Output []*Variable
	Generation    int
	Forwarder
}
Example 
package main

import (
	"fmt"

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

func main() {
	f := &variable.Function{
		Forwarder: &variable.SinT{},
	}

	y := f.Forward(variable.New(1.0))
	fmt.Println(f)
	fmt.Println(y)

}

Output:

*variable.SinT[variable(1)]
[variable(0.8414709848078965)]

func (*Function) First 

func (f *Function) First(x ...*Variable) *Variable

First applies the function and returns the first output

func (*Function) Forward 

func (f *Function) Forward(x ...*Variable) []*Variable

Forward applies the function

func (Function) String 

func (f Function) String() string

type GetItemGradT 

type GetItemGradT struct {
	Indices []int
	Shape   []int
	Axis    int
}

func (*GetItemGradT) Backward 

func (f *GetItemGradT) Backward(ggx ...*Variable) []*Variable

func (*GetItemGradT) Forward 

func (f *GetItemGradT) Forward(gy ...*Variable) []*Variable

type GetItemT 

type GetItemT struct {
	Indices []int
	Axis    int
	// contains filtered or unexported fields
}

func (*GetItemT) Backward 

func (f *GetItemT) Backward(gy ...*Variable) []*Variable

func (*GetItemT) Forward 

func (f *GetItemT) Forward(x ...*Variable) []*Variable

type LogT 

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

import (
	"fmt"

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

func main() {
	x := variable.New(1, 2, 3, 4, 5)
	f := variable.LogT{}

	fmt.Println(x)
	fmt.Println(f.Forward(x))
	fmt.Println(f.Backward(variable.OneLike(x)))

}

Output:

variable[5]([1 2 3 4 5])
[variable[5]([0 0.6931471805599453 1.0986122886681096 1.3862943611198906 1.6094379124341003])]
[variable[5]([1 0.5 0.3333333333333333 0.25 0.2])]

func (*LogT) Backward 

func (f *LogT) Backward(gy ...*Variable) []*Variable

func (*LogT) Forward 

func (f *LogT) Forward(x ...*Variable) []*Variable

type MatMulT 

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

func (*MatMulT) Backward 

func (f *MatMulT) Backward(gy ...*Variable) []*Variable

func (*MatMulT) Forward 

func (f *MatMulT) Forward(x ...*Variable) []*Variable

type MaxT 

type MaxT struct {
	Axes []int
	// contains filtered or unexported fields
}

func (*MaxT) Backward 

func (f *MaxT) Backward(gy ...*Variable) []*Variable

func (*MaxT) Forward 

func (f *MaxT) Forward(x ...*Variable) []*Variable

type MeanT added in v0.0.2 

type MeanT struct {
	Axes []int
	// contains filtered or unexported fields
}

func (*MeanT) Backward added in v0.0.2 

func (f *MeanT) Backward(gy ...*Variable) []*Variable

func (*MeanT) Forward added in v0.0.2 

func (f *MeanT) Forward(x ...*Variable) []*Variable

type MinT 

type MinT struct {
	Axes []int
	// contains filtered or unexported fields
}

func (*MinT) Backward added in v0.0.2 

func (f *MinT) Backward(gy ...*Variable) []*Variable

func (*MinT) Forward 

func (f *MinT) Forward(x ...*Variable) []*Variable

type MulT 

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

import (
	"fmt"

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

func main() {
	a := variable.New(3.0)
	b := variable.New(2.0)
	f := variable.MulT{}

	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(f.Forward(a, b))
	fmt.Println(f.Backward(variable.OneLike(a), variable.OneLike(b)))

}

Output:

variable(3)
variable(2)
[variable(6)]
[variable(2) variable(3)]

func (*MulT) Backward 

func (f *MulT) Backward(gy ...*Variable) []*Variable

func (*MulT) Forward 

func (f *MulT) Forward(x ...*Variable) []*Variable

type NegT 

type NegT struct{}

func (*NegT) Backward 

func (f *NegT) Backward(gy ...*Variable) []*Variable

func (*NegT) Forward 

func (f *NegT) Forward(x ...*Variable) []*Variable

type Opts 

type Opts struct {
	RetainGrad  bool
	CreateGraph bool
}

type PowT 

type PowT struct {
	P float64
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(3.0)
	f := variable.PowT{P: 4.0}

	fmt.Println(x)
	fmt.Println(f.Forward(x))
	fmt.Println(f.Backward(variable.OneLike(x)))

}

Output:

variable(3)
[variable(81)]
[variable(108)]

func (*PowT) Backward 

func (f *PowT) Backward(gy ...*Variable) []*Variable

func (*PowT) Forward 

func (f *PowT) Forward(x ...*Variable) []*Variable

type ReshapeT 

type ReshapeT struct {
	Shape []int
	// contains filtered or unexported fields
}

func (*ReshapeT) Backward 

func (f *ReshapeT) Backward(gy ...*Variable) []*Variable

func (*ReshapeT) Forward 

func (f *ReshapeT) Forward(x ...*Variable) []*Variable

type SinT 

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

import (
	"fmt"
	"math"

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

func main() {
	x := variable.New(math.Pi / 4)
	f := variable.SinT{}

	fmt.Println(x)
	fmt.Println(f.Forward(x))
	fmt.Println(f.Backward(variable.OneLike(x)))

}

Output:

variable(0.7853981633974483)
[variable(0.7071067811865475)]
[variable(0.7071067811865476)]

func (*SinT) Backward 

func (f *SinT) Backward(gy ...*Variable) []*Variable

func (*SinT) Forward 

func (f *SinT) Forward(x ...*Variable) []*Variable

type Span 

type Span struct {
	End func()
}

func Nograd 

func Nograd() *Span
Example 
package main

import (
	"fmt"

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

func main() {
	f := func() {
		x := variable.New(3)
		y := variable.Square(x)
		y.Backward()

		fmt.Println("gx: ", x.Grad)
		fmt.Println()
	}

	fmt.Println("backprop:", variable.Config.EnableBackprop)
	f()

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

		fmt.Println("backprop:", variable.Config.EnableBackprop)
		f()
	}()

	fmt.Println("backprop:", variable.Config.EnableBackprop)
	f()

}

Output:

backprop: true
gx:  variable(6)

backprop: false
gx:  <nil>

backprop: true
gx:  variable(6)

func TestMode 

func TestMode() *Span
Example 
package main

import (
	"fmt"

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

func main() {
	fmt.Println("train:", variable.Config.Train)

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

		fmt.Println("train:", variable.Config.Train)
	}()

	fmt.Println("train:", variable.Config.Train)

}

Output:

train: true
train: false
train: true

type SplitT added in v0.0.2 

type SplitT struct {
	Size []int
	Axis int
	// contains filtered or unexported fields
}

func (*SplitT) Backward added in v0.0.2 

func (f *SplitT) Backward(gy ...*Variable) []*Variable

func (*SplitT) Forward added in v0.0.2 

func (f *SplitT) Forward(x ...*Variable) []*Variable

type SquareT 

type SquareT struct {
	PowT
}

type SubT 

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

func (*SubT) Backward 

func (f *SubT) Backward(gy ...*Variable) []*Variable

func (*SubT) Forward 

func (f *SubT) Forward(x ...*Variable) []*Variable

type SumT 

type SumT struct {
	Axes []int
	// contains filtered or unexported fields
}

func (*SumT) Backward 

func (f *SumT) Backward(gy ...*Variable) []*Variable

func (*SumT) Forward 

func (f *SumT) Forward(x ...*Variable) []*Variable

type SumToT 

type SumToT struct {
	Shape []int
	// contains filtered or unexported fields
}

func (*SumToT) Backward 

func (f *SumToT) Backward(gy ...*Variable) []*Variable

func (*SumToT) Forward 

func (f *SumToT) Forward(x ...*Variable) []*Variable

type TanhT 

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

func (*TanhT) Backward 

func (f *TanhT) Backward(gy ...*Variable) []*Variable

func (*TanhT) Forward 

func (f *TanhT) Forward(x ...*Variable) []*Variable

type TransposeT 

type TransposeT struct {
	Axes []int
	// contains filtered or unexported fields
}

func (*TransposeT) Backward 

func (f *TransposeT) Backward(gy ...*Variable) []*Variable

func (*TransposeT) Forward 

func (f *TransposeT) Forward(x ...*Variable) []*Variable

type Variable 

type Variable struct {
	Name       string
	Data       *tensor.Tensor[float64]
	Grad       *Variable
	Creator    *Function
	Generation int
}
Example 
package main

import (
	"fmt"

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

func main() {
	v := variable.New(1, 2, 3, 4)
	fmt.Println(v)

}

Output:

variable[4]([1 2 3 4])
Example (Name) 
package main

import (
	"fmt"

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

func main() {
	v := variable.New(1, 2, 3, 4)
	v.Name = "v"
	fmt.Println(v)

}

Output:

v[4]([1 2 3 4])

func Add 

func Add(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	a := variable.New(2, 3)
	b := variable.New(3, 4)
	y := variable.Add(a, b)
	y.Backward()

	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

}

Output:

variable[2]([1 1])
variable[2]([1 1])
Example (Broadcast) 
package main

import (
	"fmt"

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

func main() {
	// p305
	a := variable.New(1, 2, 3)
	b := variable.New(10)
	y := variable.Add(a, b)
	y.Backward()

	fmt.Println(y)
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

}

Output:

variable[3]([11 12 13])
variable[3]([1 1 1])
variable(3)
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	a := variable.New(1, 2, 3)
	b := variable.New(10)

	y := variable.Add(a, b)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

	ga := a.Grad
	gb := b.Grad
	a.Cleargrad()
	b.Cleargrad()

	ga.Backward()
	gb.Backward()

	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

}

Output:

variable[3]([11 12 13])
variable[3]([1 1 1])
variable(3)
<nil>
<nil>

func AddC 

func AddC(c float64, x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(3)
	y := variable.AddC(10.0, x)
	y.Backward()

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

}

Output:

variable(13)
variable(1)

func Cos 

func Cos(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"
	"math"

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

func main() {
	// p198
	x := variable.New(math.Pi / 4)
	y := variable.Cos(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x.Grad)
	fmt.Println(1.0 / math.Sqrt2)

}

Output:

variable(0.7071067811865476)
variable(-0.7071067811865475)
0.7071067811865476
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(1.0)

	y := variable.Cos(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	for range 10 {
		gx := x.Grad
		x.Cleargrad()
		gx.Backward(variable.Opts{CreateGraph: true})
		fmt.Println(x.Grad)
	}

}

Output:

variable(0.5403023058681398)
variable(-0.8414709848078965)
variable(-0.5403023058681398)
variable(0.8414709848078965)
variable(0.5403023058681398)
variable(-0.8414709848078965)
variable(-0.5403023058681398)
variable(0.8414709848078965)
variable(0.5403023058681398)
variable(-0.8414709848078965)
variable(-0.5403023058681398)
variable(0.8414709848078965)

func Div 

func Div(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	a := variable.New(10)
	b := variable.New(2)
	y := variable.Div(a, b)
	y.Backward()

	fmt.Println(y)
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

}

Output:

variable(5)
variable(0.5)
variable(-2.5)
Example (Broadcast) 
package main

import (
	"fmt"

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

func main() {
	// p305
	a := variable.New(1, 2, 3, 4, 5)
	b := variable.New(2)
	y := variable.Div(a, b)
	y.Backward()

	fmt.Println(y)
	fmt.Println(a.Grad, b.Grad)

}

Output:

variable[5]([0.5 1 1.5 2 2.5])
variable[5]([0.5 0.5 0.5 0.5 0.5]) variable(-3.75)
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	a := variable.New(10)
	b := variable.New(2)

	y := variable.Div(a, b)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

	ga := a.Grad
	gb := b.Grad
	a.Cleargrad()
	b.Cleargrad()

	ga.Backward()
	gb.Backward()

	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

}

Output:

variable(5)
variable(0.5)
variable(-2.5)
variable(-0.25)
variable(2.25)

func DivC 

func DivC(c float64, x ...*Variable) *Variable

DivC returns c / x

Example 
package main

import (
	"fmt"

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

func main() {
	a := 10.0
	b := variable.New(2)
	y := variable.DivC(a, b)
	y.Backward()

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

}

Output:

variable(5)
variable(-2.5)

func Exp 

func Exp(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	v := variable.New(1, 2, 3, 4, 5)
	y := variable.Exp(v)
	y.Backward()

	fmt.Println(v.Grad)

}

Output:

variable[5]([2.718281828459045 7.38905609893065 20.085536923187668 54.598150033144236 148.4131591025766])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(2.0)

	y := variable.Exp(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	for i := 0; i < 3; i++ {
		gx := x.Grad
		x.Cleargrad()
		gx.Backward(variable.Opts{CreateGraph: true})
		fmt.Println(x.Grad)
	}

}

Output:

variable(7.38905609893065)
variable(7.38905609893065)
variable(7.38905609893065)
variable(7.38905609893065)
variable(7.38905609893065)

func From added in v0.0.2 

func From(v *tensor.Tensor[float64]) *Variable

func Log 

func Log(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	v := variable.New(1, 2, 3, 4, 5)
	y := variable.Log(v)
	y.Backward()

	fmt.Println(v.Grad)

}

Output:

variable[5]([1 0.5 0.3333333333333333 0.25 0.2])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(2)

	y := variable.Log(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(x.Grad)

	gx = x.Grad
	x.Cleargrad()
	gx.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(x.Grad)

	gx = x.Grad
	x.Cleargrad()
	gx.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(x.Grad)

}

Output:

variable(0.6931471805599453)
variable(0.5)
variable(-0.25)
variable(0.25)
variable(-0.375)

func MatMul 

func MatMul(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	w := variable.New(
		1, 2, 3, 4,
		5, 6, 7, 8,
		9, 10, 11, 12,
	).Reshape(3, 4)

	y := variable.MatMul(x, w)
	y.Backward()

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

}

Output:

variable[2 3]([10 26 42 10 26 42])
variable[3 4]([5 5 5 5 7 7 7 7 9 9 9 9])
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	w := variable.New(
		1, 2, 3, 4,
		5, 6, 7, 8,
		9, 10, 11, 12,
	).Reshape(3, 4)

	y := variable.MatMul(x, w)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(x.Grad)
	fmt.Println(w.Grad)

	gx := x.Grad
	gw := w.Grad
	x.Cleargrad()
	w.Cleargrad()

	gx.Backward()
	gw.Backward()
	fmt.Println(x.Grad)
	fmt.Println(w.Grad)

}

Output:

variable[2 3]([10 26 42 10 26 42])
variable[3 4]([5 5 5 5 7 7 7 7 9 9 9 9])
variable[2 3]([4 4 4 4 4 4])
variable[3 4]([2 2 2 2 2 2 2 2 2 2 2 2])

func Mul 

func Mul(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	// p139
	a := variable.New(3.0)
	b := variable.New(2.0)
	c := variable.New(1.0)
	y := variable.Add(variable.Mul(a, b), c)
	y.Backward()

	fmt.Println(y)
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

}

Output:

variable(7)
variable(2)
variable(3)
Example (Broadcast) 
package main

import (
	"fmt"

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

func main() {
	// p305
	a := variable.New(2, 2, 2, 2, 2)
	b := variable.New(3.0)
	y := variable.Mul(a, b)
	y.Backward()

	fmt.Println(y)
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

}

Output:

variable[5]([6 6 6 6 6])
variable[5]([3 3 3 3 3])
variable(10)
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	a := variable.New(3.0)
	b := variable.New(2.0)
	y := variable.Mul(a, b)

	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

	ga := a.Grad
	gb := b.Grad
	a.Cleargrad()
	b.Cleargrad()

	ga.Backward()
	gb.Backward()
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

}

Output:

variable(6)
variable(2)
variable(3)
variable(1)
variable(1)

func MulC 

func MulC(c float64, x ...*Variable) *Variable
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	b := variable.New(2.0)
	y := variable.MulC(3.0, b)

	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(b.Grad)

	gb := b.Grad
	b.Cleargrad()

	gb.Backward()
	fmt.Println(b.Grad)

}

Output:

variable(6)
variable(3)
<nil>

func Neg 

func Neg(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	// p139
	x := variable.New(3.0)
	y := variable.Neg(x)
	y.Backward()

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

}

Output:

variable(-3)
variable(-1)
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(3.0)

	y := variable.Neg(x)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(x.Grad)

	gx := x.Grad
	x.Cleargrad()
	gx.Backward()
	fmt.Println(x.Grad)

}

Output:

variable(-3)
variable(-1)
<nil>

func New 

func New(v ...float64) *Variable

func OneLike 

func OneLike(v *Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	v := variable.New(1, 2, 3, 4)
	fmt.Println(variable.OneLike(v))

}

Output:

variable[4]([1 1 1 1])

func Rand 

func Rand(shape []int, s ...randv2.Source) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	s := rand.Const()
	v := variable.Rand([]int{2, 3}, s)

	for _, row := range v.Data.Seq2() {
		fmt.Println(row)
	}

}

Output:

[0.9999275824802834 0.8856419373528862 0.38147752771154886]
[0.4812673234167829 0.44417259544314847 0.5210016660132573]

func Randn 

func Randn(shape []int, s ...randv2.Source) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	s := rand.Const()
	v := variable.Randn([]int{2, 3}, s)

	for _, row := range v.Data.Seq2() {
		fmt.Println(row)
	}

}

Output:

[0.5665360716030388 -0.6123972949371448 0.5898947122637695]
[-0.3678242340302933 1.0919575041640825 -0.4438344619606553]

func Sin 

func Sin(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"
	"math"

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

func main() {
	// p198
	x := variable.New(math.Pi / 4)
	y := variable.Sin(x)
	y.Backward()

	fmt.Println(y)
	fmt.Println(x.Grad)
	fmt.Println(1.0 / math.Sqrt2)

}

Output:

variable(0.7071067811865475)
variable(0.7071067811865476)
0.7071067811865476
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	// p243
	x := variable.New(1.0)
	y := variable.Sin(x)
	y.Backward(variable.Opts{CreateGraph: true})

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

	for range 10 {
		gx := x.Grad
		x.Cleargrad()
		gx.Backward(variable.Opts{CreateGraph: true})

		fmt.Println(x.Grad)
	}

}

Output:

variable(0.8414709848078965)
variable(0.5403023058681398)
variable(-0.8414709848078965)
variable(-0.5403023058681398)
variable(0.8414709848078965)
variable(0.5403023058681398)
variable(-0.8414709848078965)
variable(-0.5403023058681398)
variable(0.8414709848078965)
variable(0.5403023058681398)
variable(-0.8414709848078965)
variable(-0.5403023058681398)

func Square 

func Square(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(3.0)
	y := variable.Square(x)
	y.Backward()

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

}

Output:

variable(3)
variable(9)
variable(6)
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(3.0)
	y := variable.Square(x)
	y.Backward(variable.Opts{CreateGraph: true})

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

	for range 2 {
		gx := x.Grad
		x.Cleargrad()
		gx.Backward(variable.Opts{CreateGraph: true})
		fmt.Println(x.Grad)
	}

}

Output:

variable(3)
variable(9)
variable(6)
variable(2)
variable(0)

func Sub 

func Sub(x ...*Variable) *Variable

Sub returns a variable that x[0] - x[1].

Example 
package main

import (
	"fmt"

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

func main() {
	a := variable.New(3.0)
	b := variable.New(2.0)
	y := variable.Sub(a, b)
	y.Backward()

	fmt.Println(y)
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

}

Output:

variable(1)
variable(1)
variable(-1)
Example (Broadcast) 
package main

import (
	"fmt"

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

func main() {
	// p305
	a := variable.New(1, 2, 3, 4, 5)
	b := variable.New(1)
	y := variable.Sub(a, b)
	y.Backward()

	fmt.Println(y)
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

}

Output:

variable[5]([0 1 2 3 4])
variable[5]([1 1 1 1 1])
variable(-5)
Example (Double) 
package main

import (
	"fmt"

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

func main() {
	a := variable.New(3.0)
	b := variable.New(2.0)

	y := variable.Sub(a, b)
	y.Backward(variable.Opts{CreateGraph: true})
	fmt.Println(y)
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

	ga := a.Grad
	gb := b.Grad
	a.Cleargrad()
	b.Cleargrad()

	ga.Backward()
	gb.Backward()
	fmt.Println(a.Grad)
	fmt.Println(b.Grad)

}

Output:

variable(1)
variable(1)
variable(-1)
<nil>
<nil>

func SubC 

func SubC(c float64, x ...*Variable) *Variable

SubC returns a variable that c - x[0].

Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(3.0)
	y := variable.SubC(10.0, x)
	y.Backward()

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

}

Output:

variable(7)
variable(-1)

func Tanh 

func Tanh(x ...*Variable) *Variable

func ZeroLike 

func ZeroLike(v *Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	v := variable.New(1, 2, 3, 4)
	fmt.Println(variable.ZeroLike(v))

}

Output:

variable[4]([0 0 0 0])

func Zeros added in v0.0.2 

func Zeros(shape ...int) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	fmt.Println(variable.Zeros(2, 3))

}

Output:

variable[2 3]([0 0 0 0 0 0])

func (*Variable) At added in v0.0.2 

func (v *Variable) At(indices ...int) float64

At returns the value at the given indices. If no indices are given, it returns the first element.

func (*Variable) Backward 

func (v *Variable) Backward(opts ...Opts)
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(1.0)
	x.Backward()
	fmt.Println(x.Grad)

	x.Cleargrad()
	x.Backward()
	fmt.Println(x.Grad)

}

Output:

variable(1)
variable(1)

func (*Variable) Cleargrad 

func (v *Variable) Cleargrad()

func (*Variable) NumDims added in v0.0.2 

func (v *Variable) NumDims() int

NumDims returns the number of dimensions of the variable.

Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	fmt.Println(x.NumDims())

}

Output:

2

func (*Variable) Reshape added in v0.0.2 

func (v *Variable) Reshape(shape ...int) *Variable

Reshape changes the shape of the variable.

Example 
package main

import (
	"fmt"

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

func main() {
	v := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	fmt.Println(v)

}

Output:

variable[2 3]([1 2 3 4 5 6])

func (*Variable) SetCreator 

func (v *Variable) SetCreator(f *Function)

func (*Variable) Shape added in v0.0.2 

func (v *Variable) Shape() []int

Shape returns the shape of the variable.

func (*Variable) Size added in v0.0.2 

func (v *Variable) Size() int

Size returns the number of elements in the variable.

Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(
		1, 2, 3,
		4, 5, 6,
	).Reshape(2, 3)

	fmt.Println(x.Size())

}

Output:

6

func (*Variable) String 

func (v *Variable) String() string

func (*Variable) Unchain 

func (v *Variable) Unchain()
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(1.0)

	y := variable.Pow(2.0)(x)
	fmt.Println(y.Creator) // Pow

	y.Unchain()
	fmt.Println(y.Creator) // nil

}

Output:

*variable.PowT[variable(1)]
<nil>

func (*Variable) UnchainBackward 

func (v *Variable) UnchainBackward()
Example 
package main

import (
	"fmt"

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

func main() {
	x := variable.New(1.0)

	y := variable.Pow(2.0)(x)
	z := variable.Sin(y)
	fmt.Println(y.Creator) // Pow
	fmt.Println(z.Creator) // Sin

	z.UnchainBackward()
	fmt.Println(y.Creator) // nil
	fmt.Println(z.Creator) // Sin

	z.Unchain()
	z.UnchainBackward()
	fmt.Println(y.Creator) // nil
	fmt.Println(z.Creator) // nil

}

Output:

*variable.PowT[variable(1)]
*variable.SinT[variable(1)]
<nil>
*variable.SinT[variable(1)]
<nil>
<nil>

type VarianceT added in v0.0.2 

type VarianceT struct {
	Axes []int
	// contains filtered or unexported fields
}

func (*VarianceT) Backward added in v0.0.2 

func (f *VarianceT) Backward(gy ...*Variable) []*Variable

func (*VarianceT) Forward added in v0.0.2 

func (f *VarianceT) Forward(x ...*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.