Function to implement training via batch algorithm

Share:

Description

sTrainBatch is supposed to perform batch training algorithm. It requires three inputs: a "sMap" or "sInit" object, input data, and a "sTrain" object specifying training environment. The training is implemented iteratively, but instead of choosing a single input vector, the whole input matrix is used. In each training cycle, the whole input matrix first land in the map through identifying the corresponding winner hexagon/rectangle (BMH), and then the codebook matrix is updated via updating formula (see "Note" below for details). It returns an object of class "sMap".

Usage

1
sTrainBatch(sMap, data, sTrain, verbose = T)

Arguments

sMap

an object of class "sMap" or "sInit"

data

a data frame or matrix of input data

sTrain

an object of class "sTrain"

verbose

logical to indicate whether the messages will be displayed in the screen. By default, it sets to TRUE for display

Value

an object of class "sMap", a list with following components:

  • nHex: the total number of hexagons/rectanges in the grid

  • xdim: x-dimension of the grid

  • ydim: y-dimension of the grid

  • lattice: the grid lattice

  • shape: the grid shape

  • coord: a matrix of nHex x 2, with each row corresponding to the coordinates of a hexagon/rectangle in the 2D map grid

  • init: an initialisation method

  • neighKernel: the training neighborhood kernel

  • codebook: a codebook matrix of nHex x ncol(data), with each row corresponding to a prototype vector in input high-dimensional space

  • call: the call that produced this result

Note

Updating formula is: m_i(t+1) = \frac{∑_{j=1}^{dlen}h_{wi}(t)x_j}{∑_{j=1}^{dlen}h_{wi}(t)}, where

  • t denotes the training time/step

  • x_j is an input vector j from the input data matrix (with dlen rows in total)

  • i and w stand for the hexagon/rectangle i and the winner BMH w, respectively

  • m_i(t+1) is the prototype vector of the hexagon i at time t+1

  • h_{wi}(t) is the neighborhood kernel, a non-increasing function of i) the distance d_{wi} between the hexagon/rectangle i and the winner BMH w, and ii) the radius δ_t at time t. There are five kernels available:

    • For "gaussian" kernel, h_{wi}(t)=e^{-d_{wi}^2/(2*δ_t^2)}

    • For "cutguassian" kernel, h_{wi}(t)=e^{-d_{wi}^2/(2*δ_t^2)}*(d_{wi} ≤ δ_t)

    • For "bubble" kernel, h_{wi}(t)=(d_{wi} ≤ δ_t)

    • For "ep" kernel, h_{wi}(t)=(1-d_{wi}^2/δ_t^2)*(d_{wi} ≤ δ_t)

    • For "gamma" kernel, h_{wi}(t)=1/Γ(d_{wi}^2/(4*δ_t^2)+2)

See Also

sTrainology, visKernels

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
# 1) generate an iid normal random matrix of 100x10 
data <- matrix( rnorm(100*10,mean=0,sd=1), nrow=100, ncol=10)

# 2) from this input matrix, determine nHex=5*sqrt(nrow(data))=50, 
# but it returns nHex=61, via "sHexGrid(nHex=50)", to make sure a supra-hexagonal grid
sTopol <- sTopology(data=data, lattice="hexa", shape="suprahex")

# 3) initialise the codebook matrix using "uniform" method
sI <- sInitial(data=data, sTopol=sTopol, init="uniform")

# 4) define trainology at "rough" stage
sT_rough <- sTrainology(sMap=sI, data=data, stage="rough")

# 5) training at "rough" stage
sM_rough <- sTrainBatch(sMap=sI, data=data, sTrain=sT_rough)

# 6) define trainology at "finetune" stage
sT_finetune <- sTrainology(sMap=sI, data=data, stage="finetune")

# 7) training at "finetune" stage
sM_finetune <- sTrainBatch(sMap=sM_rough, data=data, sTrain=sT_rough)

Want to suggest features or report bugs for rdrr.io? Use the GitHub issue tracker.