variable

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: 6 Imported by: 0

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])

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([2 2 2])
variable([3])

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([0 0 0 1 2 4 5 5])
variable([0 0 1 1 1 1 0 0])

func GetItem 

func GetItem(slices []int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

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

	y := variable.GetItem([]int{1})(A)
	y.Backward()

	fmt.Println(y)
	fmt.Println(A.Grad)

}

Output:

variable([4 5 6])
variable([[0 0 0] [1 1 1]])
Example (Indices) 
package main

import (
	"fmt"

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

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

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

	fmt.Println(y)
	fmt.Println(A.Grad)

}

Output:

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

func GetItemGrad 

func GetItemGrad(slices, inShape []int) func(x ...*Variable) *Variable
Example 
package main

import (
	"fmt"

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

func main() {
	gy := variable.NewOf(
		[]float64{1, 1, 1},
		[]float64{1, 1, 1},
		[]float64{1, 1, 1},
	)

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

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

}

Output:

variable([[2 2 2] [1 1 1]])
variable([[1 1 1] [1 1 1] [1 1 1]])

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 IsClose 

func IsClose(a, b float64) float64

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(c 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 i := 0; i < 3; i++ {
		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.NewOf([]float64{1, 2, 3}, []float64{4, 5, 6})
	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([[1 2 3] [4 5 6]])
variable([1 2 3 4 5 6])
variable([[1 1 1] [1 1 1]])
variable([1 1 1 1 1 1])

func Shape 

func Shape(v *Variable) []int

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.NewOf(
		[]float64{1, 2, 3},
		[]float64{4, 5, 6},
	)
	y := variable.SumTo(1, 3)(x)
	y.Backward()

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

	y = variable.SumTo(2, 1)(x)
	y.Backward()
	fmt.Println(y)
	fmt.Println(x.Grad)

}

Output:

variable([5 7 9])
variable([[1 1 1] [1 1 1]])
variable([[6] [15]])
variable([[1 1 1] [1 1 1]])

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 3])
variable([3 4])
[variable([5 7])]
[variable([1 1]) variable([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 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([1 2 3 4 5])
[variable([2.718281828459045 7.38905609893065 20.085536923187668 54.598150033144236 148.4131591025766])]
[variable([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 {
	Slices  []int
	InShape []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 {
	Slices []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([1 2 3 4 5])
[variable([0 0.6931471805599453 1.0986122886681096 1.3862943611198906 1.6094379124341003])]
[variable([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 {
	// 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 MinT 

type MinT struct {
	MaxT
}

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 {
	C 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{C: 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 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 {
	// 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{}

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       [][]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([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, b.Grad)

}

Output:

variable([1 1]) variable([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, b.Grad)

}

Output:

variable([11 12 13])
variable([1 1 1]) variable([3])

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([]float64{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 i := 0; i < 10; i++ {
		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, 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([0.5 1 1.5 2 2.5])
variable([0.5 0.5 0.5 0.5 0.5]) variable([-3.75])

func DivC 

func DivC(c float64, x ...*Variable) *Variable
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([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 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([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/matrix"
	"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 := variable.MatMul(x, w)
	y.Backward()

	fmt.Println(matrix.Shape(x.Grad.Data))
	fmt.Println(matrix.Shape(w.Grad.Data))

}

Output:

[2 3]
[3 4]

func Max 

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

import (
	"fmt"

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

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

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

	fmt.Println(y)
	fmt.Println(A.Grad)

}

Output:

variable([10])
variable([[0 0 0] [0 1 0]])

func Min 

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

import (
	"fmt"

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

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

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

	fmt.Println(y)
	fmt.Println(A.Grad)

}

Output:

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

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, 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, b.Grad)

}

Output:

variable([6 6 6 6 6])
variable([3 3 3 3 3]) variable([10])

func MulC 

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

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])

func New 

func New(v ...float64) *Variable

func NewOf 

func NewOf(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([1 1 1 1])

func Rand 

func Rand(m, n 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()
	for _, r := range variable.Rand(2, 3, s).Data {
		fmt.Println(r)
	}

}

Output:

[0.9999275824802834 0.8856419373528862 0.38147752771154886]
[0.4812673234167829 0.44417259544314847 0.5210016660132573]

func Randn 

func Randn(m, n 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()
	for _, r := range variable.Randn(2, 3, s).Data {
		fmt.Println(r)
	}

}

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([]float64{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 i := 0; i < 10; i++ {
		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 i := 0; i < 2; i++ {
		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, 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, b.Grad)

}

Output:

variable([0 1 2 3 4])
variable([1 1 1 1 1]) variable([-5])

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 Sum 

func Sum(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([1 1 1 1 1 1])
Example (Matrix) 
package main

import (
	"fmt"

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

func main() {
	// p293
	x := variable.NewOf(
		[]float64{1, 2, 3},
		[]float64{4, 5, 6},
	)
	y := variable.Sum(x)
	y.Backward()

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

}

Output:

variable([21])
variable([[1 1 1] [1 1 1]])

func Tanh 

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

func Transpose 

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

import (
	"fmt"

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

func main() {
	// p286
	x := variable.NewOf([]float64{1, 2, 3}, []float64{4, 5, 6})
	y := variable.Transpose(x)
	y.Backward()

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

}

Output:

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

func Zero 

func Zero(m, n int) *Variable
Example 
package main

import (
	"fmt"

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

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

}

Output:

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

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([0 0 0 0])

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) SetCreator 

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

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>

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.