SOM Toolbox Online documentation



 Trains codebook with the LVQ3 -algorithm (described below).



 Trains codebook with the LVQ3 -algorithm. Codebook contains a number
 of vectors (mi, i=1,2,...,n) and so does data (vectors xj, j=1,2,...k).
 Both vector sets are classified: vectors may have a class (classes are
 set to data- or map -structure's 'labels' -field. For each xj the two 
 closest codebookvectors mc1 and mc2 are searched (euclidean distances
 d1 and d2). xj must fall into the zone of window. That happens if:

    min(d1/d2, d2/d1) > s, where s = (1-win) / (1+win).

 If xj belongs to the same class of one of the mc1 and mc1, codebook
 is updated as follows (let mc1 belong to the same class as xj):
    mc1(t+1) = mc1(t) + alpha * (xj(t) - mc1(t))
    mc2(t+1) = mc2(t) - alpha * (xj(t) - mc2(t))
 If both mc1 and mc2 belong to the same class as xj, codebook is
 updated as follows:
    mc1(t+1) = mc1(t) + epsilon * alpha * (xj(t) - mc1(t))
    mc2(t+1) = mc2(t) + epsilon * alpha * (xj(t) - mc2(t))
 Otherwise updating is not performed.

 Argument 'rlen' tells how many times training -sequence is performed.

 Argument 'alpha' is recommended to be smaller than 0.1 and argument
 'epsilon' should be between 0.1 and 0.5.

 NOTE: does not take mask into account.


 Kohonen, T., "Self-Organizing Map", 2nd ed., Springer-Verlag, 
    Berlin, 1995, pp. 181-182.

 See also LVQ_PAK from

Required input arguments

  sM                The data to be trained.
          (struct)  A map struct.

  data              The data to use in training.
          (struct)  A data struct.

  rlen    (integer) Running length of LVQ3 -algorithm.

  alpha   (float)   Learning rate used in training, e.g. 0.05

  win     (float)   Window length, e.g. 0.25

  epsilon (float)   Relative learning parameter, e.g. 0.3

Output arguments

  sM          Trained data.
          (struct)  A map struct.


   lab = unique(sD.labels(:,1));         % different classes
   mu = length(lab)*5;                   % 5 prototypes for each    
   sM = som_randinit(sD,'msize',[mu 1]); % initial prototypes
   sM.labels = [lab;lab;lab;lab;lab];    % their classes
   sM = lvq1(sM,sD,50*mu,0.05);          % use LVQ1 to adjust
                                         % the prototypes      
   sM = lvq3(sM,sD,50*mu,0.05,0.2,0.3);  % then use LVQ3 

See also

lvq1 Use LVQ1 algorithm for training.
som_supervised Train SOM using supervised training.
som_seqtrain Train SOM with sequential algorithm.