actrf

README

GoDoc

Package actrf provides activation-based receptive field computation, otherwise known as reverse correlation or spike-triggered averaging. It simply computes the activation weighted average of other source patterns of activation -- i.e., sum(act * src) / sum(src) which then shows you the patterns of source activity for which a given unit was active.

The RF's are computed and stored in 4D tensors, where the outer 2D are the 2D projection of the activation tensor (e.g., the activations of units in a layer), and the inner 2D are the 2D projection of the source tensor.

This results in a nice standard RF plot that can be visualized in a tensor grid view.

There is a standard ActRF which is cumulative over a user-defined interval and a RunningAvg version which is computed online and continuously updated but is more susceptible to sampling bias (i.e., more sampled areas are more active in general), and a recency bias.

See objrec CCN sim for example usage.

Documentation

Overview

Package actrf provides activation-based receptive field computation, otherwise known as reverse correlation. It simply computes the activation weighted average of other *source* patterns of activation -- i.e., sum(act * src) / sum(src) which then shows you the patterns of source activity for which a given unit was active.

The RF's are computed and stored in 4D tensors, where the outer 2D are the 2D projection of the activation tensor (e.g., the activations of units in a layer), and the inner 2D are the 2D projection of the source tensor.

This results in a nice standard RF plot that can be visualized in a tensor grid view.

There is a standard ActRF which is cumulative over a user-defined interval and a RunningAvg version which is computed online and continuously updated but is more susceptible to sampling bias (i.e., more sampled areas are more active in general), and a recency bias.

Index

• func RunningAvg(out *etensor.Float32, act, src etensor.Tensor, tau float32)
• type RF
  • func (af *RF) Add(act, src etensor.Tensor, thr float32)
  • func (af *RF) Avg()
  • func (af *RF) Init(name string, act, src etensor.Tensor)
  • func (af *RF) Norm()
  • func (af *RF) Reset()
• type RFs
  • func (af *RFs) Add(name string, act, src etensor.Tensor, thr float32) error
  • func (af *RFs) AddRF(name string, act, src etensor.Tensor) *RF
  • func (af *RFs) Avg()
  • func (af *RFs) Norm()
  • func (af *RFs) RFByName(name string) *RF
  • func (af *RFs) RFByNameTry(name string) (*RF, error)
  • func (af *RFs) Reset()

Functions

func RunningAvg

func RunningAvg(out *etensor.Float32, act, src etensor.Tensor, tau float32)

RunningAvg computes a running-average activation-based receptive field for activities act relative to source activations src (the thing we're projecting rf onto) accumulating into output out, with time constant tau. act and src are projected into a 2D space (etensor.Prjn2D* methods), and resulting out is 4D of act outer and src inner.

Types

type RF

type RF struct {
	Name    string          `desc:"name of this RF -- used for management of multiple in RFs"`
	RF      etensor.Float32 `view:"no-inline" desc:"computed receptive field, as SumProd / SumSrc -- only after Avg has been called"`
	NormRF  etensor.Float32 `view:"no-inline" desc:"unit normalized version of RF per source (inner 2D dimensions) -- good for display"`
	SumProd etensor.Float32 `view:"no-inline" desc:"sum of the products of act * src"`
	SumSrc  etensor.Float32 `view:"no-inline" desc:"sum of the sources (denomenator)"`
}

RF is used for computing an activation-based receptive field. It simply computes the activation weighted average of other *source* patterns of activation -- i.e., sum(act * src) / sum(src) which then shows you the patterns of source activity for which a given unit was active. You must call Init to initialize everything, Reset to restart the accumulation of the data, and Avg to compute the resulting averages based an accumulated data. Avg does not erase the accumulated data so it can continue beyond that point.

func (*RF) Add

func (af *RF) Add(act, src etensor.Tensor, thr float32)

Add adds one sample based on activation and source tensor values. these must be of the same shape as used when Init was called. thr is a threshold value on sources below which values are not added (prevents numerical issues with very small numbers)

func (*RF) Avg

func (af *RF) Avg()

Avg computes RF as SumProd / SumSrc. Does not Reset sums.

func (*RF) Init

func (af *RF) Init(name string, act, src etensor.Tensor)

Init initializes this RF based on name and shapes of given tensors representing the activations and source values.

func (*RF) Norm

func (af *RF) Norm()

Norm computes unit norm of RF values

func (*RF) Reset

func (af *RF) Reset()

Reset reinitializes the Sum accumulators -- must have called Init first

type RFs

type RFs struct {
	NameMap map[string]int `desc:"map of names to indexes of RFs"`
	RFs     []*RF          `desc:"the RFs"`
}

RFs manages multiple named RF's -- each one must be initialized first but functions like Avg, Norm, and Reset can be called generically on all.

func (*RFs) Add

func (af *RFs) Add(name string, act, src etensor.Tensor, thr float32) error

Add adds a new act sample to the accumulated data for given named rf

func (*RFs) AddRF

func (af *RFs) AddRF(name string, act, src etensor.Tensor) *RF

AddRF adds a new RF, calling Init on it using given act, src tensors

func (*RFs) Avg

func (af *RFs) Avg()

Avg computes RF as SumProd / SumTarg. Does not Reset sums.

func (*RFs) Norm

func (af *RFs) Norm()

Norm computes unit norm of RF values

func (*RFs) RFByName

func (af *RFs) RFByName(name string) *RF

RFByName returns RF of given name, nil if not found

func (*RFs) RFByNameTry

func (af *RFs) RFByNameTry(name string) (*RF, error)

RFByNameTry returns RF of given name, nil and error msg if not found

func (*RFs) Reset

func (af *RFs) Reset()

Reset resets Sum accumulations for all rfs