popcode

README

GoDoc

Package popcode provides population code encoding and decoding support functionality, in 1D and 2D.

popcode.OneD

popcode.OneD Encode method turns a single scalar value into a 1D population code according to a set of parameters about the nature of the population code, range of values to encode, etc.

Decode takes a distributed pattern of activity and decodes a scalar value from it, using activation-weighted average based on tuning value of individual units.

popcode.TwoD

popcode.TwoD likewise has Encode and Decode methods for 2D gaussian-bumps that simultaneously encode a 2D value such as a 2D position.

popcode.Ring

popcode.Ring is a version of popcode.OneD for values that wrap-around, such as an angle -- set the Min and Max to the exact values with no extra (e.g., 0, 360 for angle).

Documentation

Overview

Package `popcode` provides population code encoding and decoding support functionality, in 1D and 2D.

`popcode.OneD` `Encode` method turns a single scalar value into a 1D population code according to a set of parameters about the nature of the population code, range of values to encode, etc.

`Decode` takes a distributed pattern of activity and decodes a scalar value from it, using activation-weighted average based on tuning value of individual units.

`popcode.TwoD` likewise has `Encode` and `Decode` methods for 2D gaussian-bumps that simultaneously encode a 2D value such as a 2D position.

Index

• type OneD
  • func (pc *OneD) Decode(pat []float32) float32
  • func (pc *OneD) Defaults()
  • func (pc *OneD) Encode(pat *[]float32, val float32, n int)
  • func (pc *OneD) SetRange(min, max, sigma float32)
  • func (pc *OneD) Values(vals *[]float32, n int)
• type PopCodes
• type Ring
  • func (pc *Ring) AllocVecs(n int)
  • func (pc *Ring) Decode(pat []float32) float32
  • func (pc *Ring) Encode(pat *[]float32, val float32, n int)
  • func (pc *Ring) EncodeImpl(pat *[]float32, val float32, n int)
  • func (pc *Ring) Values(vals *[]float32, n int)
• type TwoD
  • func (pc *TwoD) Decode(pat []float32) float32
  • func (pc *TwoD) Defaults()
  • func (pc *TwoD) Encode(pat etensor.Tensor, val mat32.Vec2) error
  • func (pc *TwoD) SetRange(min, max, sigma float32)
  • func (pc *TwoD) Values(vals etensor.Tensor) error

Types

type OneD

type OneD struct {
	Code   PopCodes `desc:"how to encode the value"`
	Min    float32  `` /* 168-byte string literal not displayed */
	Max    float32  `` /* 168-byte string literal not displayed */
	Sigma  float32  `` /* 149-byte string literal not displayed */
	Clip   bool     `desc:"ensure that encoded and decoded value remains within specified range"`
	Thr    float32  `` /* 201-byte string literal not displayed */
	MinSum float32  `` /* 174-byte string literal not displayed */
}

popcode.OneD provides encoding and decoding of population codes, used to represent a single continuous (scalar) value across a population of units / neurons (1 dimensional)

func (*OneD) Decode

func (pc *OneD) Decode(pat []float32) float32

Decode decodes value from a pattern of activation as the activation-weighted-average of the unit's preferred tuning values. must have 2 or more values in pattern pat.

func (*OneD) Defaults

func (pc *OneD) Defaults()

func (*OneD) Encode

func (pc *OneD) Encode(pat *[]float32, val float32, n int)

Encode generates a pattern of activation of given size to encode given value. n must be 2 or more. pat slice will be constructed if len != n

func (*OneD) SetRange

func (pc *OneD) SetRange(min, max, sigma float32)

SetRange sets the min, max and sigma values

func (*OneD) Values

func (pc *OneD) Values(vals *[]float32, n int)

Values sets the vals slice to the target preferred tuning values for each unit, for a distribution of given size n. n must be 2 or more. vals slice will be constructed if len != n

type PopCodes

type PopCodes int

const (
	// GaussBump = gaussian bump, with value = weighted average of tuned unit values
	GaussBump PopCodes = iota

	// Localist = each unit represents a distinct value; intermediate values represented by graded activity of neighbors; overall activity is weighted-average across all units
	Localist
)

type Ring

type Ring struct {
	OneD
	LowVec  []float32 `view:"-" desc:"low-end encoding vector"`
	HighVec []float32 `view:"-" desc:"high-end encoding vector"`
}

Ring is a OneD popcode that encodes a circular value such as an angle that wraps around at the ends. It uses two internal vectors to render the wrapped-around values into, and then adds them into the final result. Unlike regular PopCodes, the Min and Max should represent the exact range of the value (e.g., 0 to 360 for angle) with no extra on the ends, as that extra will wrap around to the other side in this case.

func (*Ring) AllocVecs

func (pc *Ring) AllocVecs(n int)

AllocVecs allocates internal LowVec, HighVec storage, allowing for variable lengths to be encoded using same object, growing capacity to max, but using exact amount each time

func (*Ring) Decode

func (pc *Ring) Decode(pat []float32) float32

Decode decodes value from a pattern of activation as the activation-weighted-average of the unit's preferred tuning values. must have 2 or more values in pattern pat.

func (*Ring) Encode

func (pc *Ring) Encode(pat *[]float32, val float32, n int)

Encode generates a pattern of activation of given size to encode given value. n must be 2 or more. pat slice will be constructed if len != n

func (*Ring) EncodeImpl

func (pc *Ring) EncodeImpl(pat *[]float32, val float32, n int)

EncodeImpl generates a pattern of activation of given size to encode given value. n must be 2 or more. pat slice will be constructed if len != n

func (*Ring) Values

func (pc *Ring) Values(vals *[]float32, n int)

Values sets the vals slice to the target preferred tuning values for each unit, for a distribution of given size n. n must be 2 or more. vals slice will be constructed if len != n

type TwoD

type TwoD struct {
	Code   PopCodes   `desc:"how to encode the value"`
	Min    mat32.Vec2 `` /* 180-byte string literal not displayed */
	Max    mat32.Vec2 `` /* 180-byte string literal not displayed */
	Sigma  mat32.Vec2 `` /* 150-byte string literal not displayed */
	Clip   bool       `desc:"ensure that encoded and decoded value remains within specified range"`
	Thr    float32    `` /* 201-byte string literal not displayed */
	MinSum float32    `` /* 174-byte string literal not displayed */
}

popcode.TwoD provides encoding and decoding of population codes, used to represent two continuous (scalar) values across a 2D population of units / neurons (2 dimensional)

func (*TwoD) Decode

func (pc *TwoD) Decode(pat []float32) float32

Decode decodes value from a pattern of activation as the activation-weighted-average of the unit's preferred tuning values. must have 2 or more values in pattern pat. TODO: TBD

func (*TwoD) Defaults

func (pc *TwoD) Defaults()

func (*TwoD) Encode

func (pc *TwoD) Encode(pat etensor.Tensor, val mat32.Vec2) error

Encode generates a pattern of activation on given tensor, which must already have appropriate 2D shape which is used for encoding sizes (error if not).

func (*TwoD) SetRange

func (pc *TwoD) SetRange(min, max, sigma float32)

SetRange sets the min, max and sigma values to the same scalar values

func (*TwoD) Values

func (pc *TwoD) Values(vals etensor.Tensor) error

Values sets the vals 2D tensor to the target preferred tuning values for each unit, for a distribution of given size for shape of tensor. tensor must have 2D shape with dims 2 or larger (error if not) TODO: TBD requires 2 separate float vecs it seems