Contents

 

Multi-layer perceptron for encoder

This example shows how to build a network that is trained as an encoder. This example is also present as an example of the original SNNS. It shows how to build the network completely from scratch, and shows how to load patterns into the SNNS kernel. It only uses functionality directly present in SnnsCLib, and therefor can be used for guidance with any kind of network that could be built and used in SNNS.

First, we create the SnnsR object and set learning and update function, and unit defaults: 

  R> mySnnsObject <- SnnsRObjectFactory() 
  R> mySnnsObject$setLearnFunc('Quickprop') 
  R> mySnnsObject$setUpdateFunc('Topological_Order') 
  R> mySnnsObject$setUnitDefaults(1,0,1,0,1,'Act_Logistic','Out_Identity')

Then, we create the input layer:

 

  R> inputs <- vector()  
  R> for(i in 1:9) { 
  + 
  +    num <-  mySnnsObject$createDefaultUnit() 
  +    inputs[i] <- num
  + 
  +    mySnnsObject$setUnitName(num,paste("Input_",i,sep="")) 
  +    mySnnsObject$setUnitPosition(num, i, 0, 0) 
  +  }

We create and the hidden layer:

 

  R> hidden <- vector() 
  R> for(i in 1:4) { 
  + 
  +    num <- mySnnsObject$createDefaultUnit() 
  +    hidden[i] <- num 
  + 
  +    mySnnsObject$setUnitName(num,paste("Hidden_",i,sep="")) 
  + 
  +    #HIDDEN 
  +    mySnnsObject$setUnitTType(num,3) 
  + 
  +    mySnnsObject$setUnitPosition(num, i+3, 2, 0) 
  +    mySnnsObject$setCurrentUnit(num) 
  +    for(j in inputs)  { 
  +      mySnnsObject$createLink(j,0); 
  +    }; 
  +  }

And we create the output layer:

 

  R> outputs <- vector() 
  R> for(i in 1:9) { 
  + 
  +    num <- mySnnsObject$createDefaultUnit() 
  +    outputs[i] <- num 
  + 
  +    mySnnsObject$setUnitName(num,paste("Output_",i,sep="")) 
  + 
  +    #OUTPUT 
  +    mySnnsObject$setUnitTType(num,2) 
  + 
  +    mySnnsObject$setUnitPosition(num, i, 4, 0) 
  +    mySnnsObject$setCurrentUnit(num) 
  +    for(j in hidden)  { 
  +      mySnnsObject$createLink(j,0); 
  +    }; 
  +  } 
  R>

Now, we create patterns and load them directly into the SNNS kernel:

 

  R> mySnnsObject$deleteAllPatterns() 
  R> patset <- mySnnsObject$allocNewPatternSet() 
  R> for(unum in 1:9)  { 
  +    for(curnum in 1:9)  { 
  +      mySnnsObject$setUnitActivation(inputs[curnum], as.numeric(curnum == unum)); 
  +      mySnnsObject$setUnitActivation(outputs[curnum], as.numeric(curnum == unum)); 
  +    } 
  +    mySnnsObject$newPattern(); 
  +  }

Then, we initialize the net, tell the SNNS kernel to shuffle the patterns and define the subpatterns. The last step is very important, as SNNS initializes here some things, and often crashes are caused be a missing call to this function:

 

  R> mySnnsObject$initializeNet(-1) 
  R> mySnnsObject$shufflePatterns(TRUE) 
  R> mySnnsObject$DefTrainSubPat()

Now, we perform 500 epochs of training:

 

  R> error <- vector() 
  R> for(i in 1:500) { 
  +    res <- mySnnsObject$learnAllPatterns(c(0.2, 0, 0, 0, 0)) 
  +    if(res[[1]] != 0) print(paste("An error occured at iteration ", i, " : ", res, sep="")) 
  +    error[i] <- res[[2]] 
  +  } 
  R>

We show (part of) the iterative error and the weights in the trained network:

 

  R> error[1:50]

 

   [1] 10.164649  9.484868  9.039003  8.739706  8.534049  8.389607 
   [7]  8.286112  8.210589  8.154544  8.112294  8.079964  8.054860 
  [13]  8.035089  8.019297  8.006491  7.995951  7.987140  7.979659 
  [19]  7.973204  7.967545  7.962503  7.957944  7.953761  7.949869 
  [25]  7.946204  7.942714  7.939359  7.936104  7.932925  7.929798 
  [31]  7.926709  7.923642  7.920584  7.917527  7.914462  7.911382 
  [37]  7.908283  7.905157  7.902003  7.898815  7.895591  7.892326 
  [43]  7.889021  7.885669  7.882271  7.878822  7.875320  7.871766 
  [49]  7.868155  7.864487

 

  R> mySnnsObject$getCompleteWeightMatrix()

 

           Input_1 Input_2 Input_3 Input_4 Input_5 Input_6 Input_7 
  Input_1        0       0       0       0       0       0       0 
  Input_2        0       0       0       0       0       0       0 
  Input_3        0       0       0       0       0       0       0 
  Input_4        0       0       0       0       0       0       0 
  Input_5        0       0       0       0       0       0       0 
  Input_6        0       0       0       0       0       0       0 
  Input_7        0       0       0       0       0       0       0 
  Input_8        0       0       0       0       0       0       0 
  Input_9        0       0       0       0       0       0       0 
  Hidden_1       0       0       0       0       0       0       0 
  Hidden_2       0       0       0       0       0       0       0 
  Hidden_3       0       0       0       0       0       0       0 
  Hidden_4       0       0       0       0       0       0       0 
  Output_1       0       0       0       0       0       0       0 
  Output_2       0       0       0       0       0       0       0 
  Output_3       0       0       0       0       0       0       0 
  Output_4       0       0       0       0       0       0       0 
  Output_5       0       0       0       0       0       0       0 
  Output_6       0       0       0       0       0       0       0 
  Output_7       0       0       0       0       0       0       0 
  Output_8       0       0       0       0       0       0       0 
  Output_9       0       0       0       0       0       0       0 
           Input_8 Input_9   Hidden_1   Hidden_2  Hidden_3    Hidden_4 
  Input_1        0       0  1.3717262 -1.9811983 -5.449057  0.23095299 
  Input_2        0       0 -0.4608607 -0.3774811  2.325248 -5.88232374 
  Input_3        0       0  2.7502232  3.4617717 -2.620971 -3.12260556 
  Input_4        0       0 -5.1771669 -2.5431876  3.805359  0.41027644 
  Input_5        0       0 -1.5170532  1.2722431  1.766146  0.01864875 
  Input_6        0       0 -2.1087668 -3.4320893 -3.041694 -2.44326687 
  Input_7        0       0  4.6216679 -3.5145221  2.036198 -0.77750003 
  Input_8        0       0 -3.7256753  3.0482569 -1.941554  2.58770466 
  Input_9        0       0  1.5746197 -1.0840831 -1.028068  4.43720341 
  Hidden_1       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Hidden_2       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Hidden_3       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Hidden_4       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Output_1       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Output_2       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Output_3       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Output_4       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Output_5       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Output_6       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Output_7       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Output_8       0       0  0.0000000  0.0000000  0.000000  0.00000000 
  Output_9       0       0  0.0000000  0.0000000  0.000000  0.00000000 
            Output_1   Output_2  Output_3   Output_4    Output_5 
  Input_1   0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Input_2   0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Input_3   0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Input_4   0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Input_5   0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Input_6   0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Input_7   0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Input_8   0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Input_9   0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Hidden_1  1.750411 -0.9284166  2.141353 -5.4761276 -1.60732210 
  Hidden_2 -2.530504 -0.6248255  2.965932 -2.4729178  1.21654558 
  Hidden_3 -5.267370  2.7738271 -3.008966  3.1070700  1.38471162 
  Hidden_4  1.446189 -5.5624638 -3.565892  0.0282995  0.02681865 
  Output_1  0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Output_2  0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Output_3  0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Output_4  0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Output_5  0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Output_6  0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Output_7  0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Output_8  0.000000  0.0000000  0.000000  0.0000000  0.00000000 
  Output_9  0.000000  0.0000000  0.000000  0.0000000  0.00000000 
            Output_6  Output_7  Output_8  Output_9 
  Input_1   0.000000  0.000000  0.000000  0.000000 
  Input_2   0.000000  0.000000  0.000000  0.000000 
  Input_3   0.000000  0.000000  0.000000  0.000000 
  Input_4   0.000000  0.000000  0.000000  0.000000 
  Input_5   0.000000  0.000000  0.000000  0.000000 
  Input_6   0.000000  0.000000  0.000000  0.000000 
  Input_7   0.000000  0.000000  0.000000  0.000000 
  Input_8   0.000000  0.000000  0.000000  0.000000 
  Input_9   0.000000  0.000000  0.000000  0.000000 
  Hidden_1 -2.013538  3.604454 -4.299232  1.171103 
  Hidden_2 -2.939286 -3.385234  2.666383 -1.161300 
  Hidden_3 -2.730327  1.899204 -2.505809 -1.107888 
  Hidden_4 -2.432225 -1.572578  2.410651  3.203997 
  Output_1  0.000000  0.000000  0.000000  0.000000 
  Output_2  0.000000  0.000000  0.000000  0.000000 
  Output_3  0.000000  0.000000  0.000000  0.000000 
  Output_4  0.000000  0.000000  0.000000  0.000000 
  Output_5  0.000000  0.000000  0.000000  0.000000 
  Output_6  0.000000  0.000000  0.000000  0.000000 
  Output_7  0.000000  0.000000  0.000000  0.000000 
  Output_8  0.000000  0.000000  0.000000  0.000000 
  Output_9  0.000000  0.000000  0.000000  0.000000

We plot the error:

 


  R> plot(error, type="l")

PIC

Figure 1: The iterative error while training.

 


To save the results, we could do:

  R> basePath <- ("./") 
  R> mySnnsObject$saveNet(paste(basePath,"encoderSnnsCLib_untrained.net",sep=""),
    +  "encoderSnnsCLib_untrained") 
  R> mySnnsObject$saveNet(paste(basePath,"encoderSnnsCLib.net",sep=""),
    +  "encoderSnnsCLib") 
  R> mySnnsObject$saveNewPatterns(paste(basePath,"encoderSnnsCLib.pat",sep=""), 
    +  patset$set_no)

Recurrent Elman network to train an eight

This example shows how to train an Elman network using the low-level API with the eight-dataset from the SNNS examples. First, we load the data:

 

  R> data(snnsData) 
  R> inputs <- snnsData$eight_016.pat[,inputColumns(snnsData$eight_016.pat)] 
  R> outputs <- snnsData$eight_016.pat[,outputColumns(snnsData$eight_016.pat)] 
  R>

Then, we generate the SnnsR object and set learning- and update function, and unit defaults:

 

  R> snnsObject <- SnnsRObjectFactory() 
  R> snnsObject$setLearnFunc('JE_BP') 
  R> snnsObject$setUpdateFunc('JE_Order') 
  R> snnsObject$setUnitDefaults(1,0,1,0,1,'Act_Logistic','Out_Identity') 
  R>

Then, we use bignet to create the Elman network (a Jordan network could be built very similarly):

 

  R> snnsObject$elman_createNet(c(2,8,2),c(1,1,1),FALSE) 
  R> #snnsObject$jordan_createNet(2,8,2,1,2,1) 
  R>

We load the pattern set into the kernel:

 

  R> patset <- snnsObject$createPatSet(inputs, outputs) 
  R> snnsObject$setCurrPatSet(patset$set_no) 
  R>

We initialize the net:

 

  R> snnsObject$initializeNet(c(1.0,  -1.0,  0.3,  1.0,  0.5) ) 
  R> snnsObject$shufflePatterns(TRUE) 
  R> snnsObject$DefTrainSubPat()

We learn 1000 epochs:

 

  R> parameters <- c(0.2, 0, 0, 0, 0) 
  R> maxit <- 1000 
  R> error <- vector() 
  R> for(i in 1:maxit) { 
  +    res <- snnsObject$learnAllPatterns(parameters) 
  +    if(res[[1]] != 0) print(paste("An error occured at iteration ", i, " : ", res, sep="")) 
  +    error[i] <- res[[2]] 
  +  } 
  R>

We plot the error:

 


  R> plot(error, type="l")

PIC

Figure 2: The iterative error while training.

 


We save the results:

  R> basePath <- ("./") 
  R> snnsObject$saveNet(paste(basePath,"eight_elmanSnnsR_untrained.net",sep=""),
   +  "eight_elmanSnnsR_untrained") 
  R> snnsObject$saveNet(paste(basePath,"eight_elmanSnnsR.net",sep=""),"eight_elmanSnnsR") 
  R> snnsObject$saveNewPatterns(paste(basePath,"eight_elmanSnnsR.pat",sep=""), patset$set_no);

Self-organizing map for clustering the cube data

This example shows the use of a SOM with the cube example data of SNNS. First, we load the data:

 

  R> data(snnsData) 
  R> inputs <- snnsData$som_cube.pat 
  R> targets <- NULL

We generate the SOM using the bignet tool:

 

  R> mapX <- 16 
  R> mapY <- 18 
  R> snnsObject <- SnnsRObjectFactory() 
  R> snnsObject$setLearnFunc('Kohonen') 
  R> snnsObject$setUpdateFunc('Kohonen_Order') 
  R> snnsObject$setInitialisationFunc('Kohonen_Weights_v3.2') 
  R> snnsObject$setUnitDefaults(0,0,3,0,1,'Act_Logistic','Out_Identity') 
  R> snnsObject$kohonen_createNet(mapX,mapY,ncol(inputs),mapX*mapY) 
  R> snnsObject$setTTypeUnitsActFunc("UNIT_HIDDEN", "Act_Euclid") 
  R>

We load the data into the kernel:

 

  R> patset <- snnsObject$createPatSet(inputs) 
  R> snnsObject$setCurrPatSet(patset$set_no)

We initialize the net:

 

  R> snnsObject$initializeNet(c(1.0,  -1.0)) 
  R> snnsObject$shufflePatterns(TRUE) 
  R> snnsObject$DefTrainSubPat()

And train 1000 iterations:

 

  R> #parameters <- c(0.855, 9.0, 0.9, 0.9, 16.0) 
  R> #parameters <- c(0.855, mapX/2, 0.9, 0.9, mapX) 
  R> parameters <- c(0.5, mapX/2, 0.8, 0.8, mapX) 
  R> maxit <- 1000 
  R> for(i in 1:maxit) { 
  +    res <- snnsObject$learnAllPatterns(parameters) 
  +    if(res[[1]] != 0) print(paste("An error occured at iteration ", i, " : ", res, sep="")) 
  +  } 
  R>

We get the results:

 

  R> actMaps <- snnsObject$predictCurrPatSet("som", c(0.0, 0.0, 1.0)) 
  R> actMaps <- matrixToActMapList(actMaps, mapX) 
  R> compMaps <- snnsObject$somPredictComponentMaps(c(0.0, 0.0, 1.0)) 
  R> compMaps <- matrixToActMapList(compMaps, mapX) 
  R> compMaps

 


  R> par(mfrow=c(3,3)) 
  R> for (i in 1:3) plotActMap(compMaps[[i]], col=topo.colors(12)) 
  R> patsetWinners  snnsObject$somPredictCurrPatSetWinners(c(0.0, 0.0, 1.0), targets=targets) 
  R> nWinnersMap  vectorToActMap(patsetWinners$nWinnersPerUnit, mapX) 
  R> plotActMap(nWinnersMap, col=rev(heat.colors(12))) 
  R> persp(1:mapX, 1:mapY, log(nWinnersMap+1), theta = 30, phi = 30, expand = 0.5, 
    +  col = "lightblue") 
  R> plotActMap(log(nWinnersMap+1), col=rev(heat.colors(12))) 
  R> plotActMap(log(nWinnersMap+1), col=topo.colors(12))

PIC

Figure 3: Results of the SOM training.

 


We save the results in SNNS format:

  R> basePath <- ("./") 
  R> snnsObject$saveNet(paste(basePath,"som_cubeSnnsR_untrained.net",sep=""),
   +  "som_cubeSnnsR_untrained") 
  R> snnsObject$saveNet(paste(basePath,"som_cubeSnnsR.net",sep=""),"som_cubeSnnsR") 
  R> snnsObject$saveNewPatterns(paste(basePath,"som_cubeSnnsR.pat",sep=""), patset$set_no);

RBF with dynamic decay adjustment for the spirals data

This is the SNNS example for the RBF-DDA algorithm with the spirals data. First, we load the data:

 

  R> data(snnsData) 
  R> inputs <- snnsData$spirals.pat[,inputColumns(snnsData$spirals.pat)] 
  R> outputs <- snnsData$spirals.pat[,outputColumns(snnsData$spirals.pat)]

Then, we build the network, creating a network with 2 input and 2 output units, without any hidden units (these will be created automatically by the algorithm):

 

  R> snnsObject <- SnnsRObjectFactory() 
  R> snnsObject$setLearnFunc('RBF-DDA') 
  R> snnsObject$setUpdateFunc('Topological_Order') 
  R> snnsObject$setUnitDefaults(0,0,1,0,1,'Act_Logistic','Out_Identity') 
  R> snnsObject$createNet(c(2,2), fullyConnectedFeedForward = FALSE)

We load the patterns into the kernel:

 

  R> patset <- snnsObject$createPatSet(inputs, outputs) 
  R> snnsObject$setCurrPatSet(patset$set_no) 
  R>

We initialize the network. As no hidden units are present, the weights do not have to be initialized:

 

  R> snnsObject$shufflePatterns(TRUE) 
  R> snnsObject$DefTrainSubPat()

We learn and get the predictions of the training data, i.e., the fit:

 

  R> parameters <- c(0.4, 0.2, 5) 
  R> res<-  snnsObject$learnAllPatterns(parameters) 
  R> predictions <- snnsObject$predictCurrPatSet("output", c(0)) 
  R>

We compute the confusion matrix:

 

  R> p <- encodeClassLabels(predictions, method="WTA", l=0, h=0) 
  R> t <- encodeClassLabels(outputs) 
  R> confusionMatrix(t,p)

 

         predictions 
  targets  1  2 
        1 96  1 
        2  2 95

Finally, we save the patterns and the network:

 

  R> basePath <- ("./") 
  R> snnsObject$saveNet(paste(basePath,"rbfDDA_spiralsSnnsR_untrained.net",sep=""),
    +  "rbfDDA_spiralsSnnsR_untrained") 
  R> snnsObject$saveNet(paste(basePath,"rbfDDA_spiralsSnnsR.net",sep=""),
    +  "rbfDDA_spiralsSnnsR") 
  R> snnsObject$saveNewPatterns(paste(basePath,"rbfDDA_spiralsSnnsR.pat",sep=""), 
    +   patset$set_no);