\chapter{Tools for SNNS}
\index{Tools}
\label{SNNStools}
\thispagestyle{empty}

\section {Overview}

There are the following tools available to ease the use of SNNS:

\begin {tabbing}
Units Struct> \qquad         \=  Struct \= \kill
{\tt analyze:} \> \> analyzes result files generated by SNNS to test the classification \\
\> \>capabilities of the corresponding net\\

{\tt bignet:} \> \>  feedforward network generator\\
{\tt Convert2snns:} \> \>  pattern conversion tool for Kohonen Networks\\
{\tt feedback-gennet:} \> \> generator for network definition files\\
{\tt mkhead:} \> \> writes SNNS pattern file header to stdout\\
{\tt mkout:} \> \> writes SNNS output pattern to stdout\\
{\tt mkpat:} \> \> reads 8 bit rawfile and writes SNNS pattern file to stdout\\
{\tt netlearn:} \> \> backpropagation test program\\
{\tt netperf:} \> \>benchmark program\\
{\tt pat\_sel:} \> \>produces pattern file with selected patterns\\
{\tt snns2c:} \> \>compiles an SNNS network file into an executable C source.\\
\end {tabbing}

\section {Analyze}
\index{Tools!Analyze}

The purpose of this tool is to analyze the result files that have been
created by SNNS. The result file which you want to analyze has to
contain the {\tt teaching output} and the {\tt output of the network}.
 
Synopsis: {\tt analyze} [-options]

It is possible to choose between the following options in any order:
\begin {tabbing}
Units Struct> \qquad         \= Struct \= \kill
{\tt -w} \> \> numbers of patterns which were classified wrong are printed\\
{\tt -r} \> \> numbers of patterns which were classified right are printed\\
{\tt -u} \> \> numbers of patterns which were not classified are printed\\
{\tt -a} \> \> same as -w -r -u\\
{\tt -v} \> \> verbose output. Each printed number is preceded by one of the \\
\> \> words 'wrong', 'right' or 'unknown' depending on the result of the\\ 
\> \> classification.\\ 
{\tt -s} \> \> statistic information containing wrong, right and not classified\\
\> \> patterns.\\
\> \> The network error is printed also.\\ 
{\tt -c} \> \> same as -s, but statistics for each output unit (class) is displayed.\\
{\tt -i <file name>} \> \> name of the 'result file' which is going to be analyzed.\\
{\tt -o <file name>} \> \> name of the file which is going to be produced by {\tt analyze}.\\
{\tt -e <function>} \> \> defines the name of the 'analyzing function'.\\
\> \> Possible names are: 402040, WTA, band (description see below)\\
{\tt -l <real value>} \> \> first parameter of the analyzing function.\\
{\tt -h <real value>} \> \> second parameter of the analyzing function.\\
\end{tabbing}

Starting {\tt analyze} without any options is equivalent to:\\
\hspace*{1.5cm} {\tt analyze -w -e 402040 -l 0.4 -h 0.6}


\subsection{Analyzing Functions}

The classification of the patterns depends on the analyzing function.
{\tt 402040} stands for the '402040' rule. That means on a range from
0 to 1 h will be 0.6 (upper 40\%) and l will be 0.4 (lower 40\%). The
middle 20\% is represented by h-l. The classification of the patterns
will depend on h, l and other constrains (see {\tt 402040} below).\\ 
{\tt WTA} stands for winner takes all. That means the classification
depends on the unit with the highest output and other constrains (see
{\tt WTA} below). {\tt Band} is an analyzing function that checks a
band of values around the teaching output. This is the only analyzing
function that treats teaching outputs of value zero correctly.
 
{\bf 402040:}\\
  A pattern is classified correctly if:
  \begin{itemize}
  \item the output of exactly one output unit is $\geq$ h.
  \item the 'teaching output' of this unit is the maximum teaching output
    of the pattern. 
  \item the output of all other output units is $\leq$ 1.
  \end{itemize}

  A pattern is classified incorrectly if:
  \begin{itemize}
  \item the output of exactly one output unit is $\geq$ h.
  \item the 'teaching output' of this unit is {\tt NOT} the maximum 
    'teaching output' of the pattern.
  \item the output of all other units is $\leq$ 1.
  \end{itemize}

  A pattern is unclassified in all other cases.

\clearpage
{\bf WTA:}\\
  A pattern is classified correctly if:
  \begin{itemize}
  \item there is an output unit with the value greater than the output
    value of all other output units (this output value is supposed to be 0).
  \item 0 $>$ h.
  \item the 'teaching output of this unit is the maximum 'teaching output'
    of the pattern.
  \item the output of all other units is $<$ a-1.
  \end{itemize}

  A pattern is classified incorrectly if:
  \begin{itemize}
  \item there is an output unit with the value greater than the output
    value of all other output units  (this output value is supposed to be
    0). 
  \item 0 $>$ h.
  \item the 'teaching output ' of this unit is {\tt NOT} the maximum
    'teaching output' of the pattern. 
  \item the output of all other output units is $<$ a-1.
  \end{itemize}

  A pattern is unclassified in all other cases.\\

{\bf Band:}\\
  A pattern is classified correctly if for all output units:
  \begin{itemize}
  \item the output is $>=$ the teaching output - low.
  \item the output is $<=$ the teaching output + high.
  \end{itemize}

  A pattern is classified incorrectly if for all output units:
  \begin{itemize}
  \item the output is $<=$ the teaching output - low.\\
  or
  \item the output is $>=$ the teaching output + high.
  \end{itemize}
\vspace{1ex}

Default values used for l and h are: l=0.0 h=0.0

\section {Bignet}
\index{Tools!Bignet}

This program is a generator for special 3-layered feedforward 
networks. It is a demo for using the SNNS kernel interface to
create networks.
It has nothing to do with the XGUI bignet tool.

Synopsis: {\tt bignet}

example:

\begin{tabbing}
XXXX \= XXXXXXXXXXXXXX \= XXXXXX \=  \kill
\> {\tt unix>} bignet \\
produces\\
\> \\
\> SNNS 3D-Kernel 4.0
\> --- Network Generator for 3 Layer Feedforward Networks ---\\
\> \\
\> No. of input units: \> 35\\
\> No. of output units: \> 26\\
\> No. of hidden units: \> 10\\
\> \\
\> Create Units now...\\
\> make connections\\
\> \\
\> Name of the network : \> \> test\\
\> Filename of the network to save: \> \> test.net\\
\> Saving the network...
\end {tabbing}

\section{Convert2snns}
\index{Tools!Convert2snns}

In order to work with the KOHONEN tools in SNNS, a pattern file 
and a network file with a special format are necessary.

Convert2snns will accomplish three important things:

\begin {itemize}
\item Creation of a 2-dimensional Kohonen Feature Map with n components
\item Weight files are converted in a SNNS compatible .net file
\item A file with raw patterns is converted in a .pat file
\end {itemize}

When working with convert2snns, 3 files are necessary:

\begin {enumerate}
\item A control file, containing the configuration of the network
\item A file with weight vectors
\item A file with raw patterns
\end {enumerate}

\subsection{Setup and Structure of a Control, Weight, Pattern File}

Each line of the control file begins with a {\tt KEYWORD} followed by the
respective declaration. The order of the keywords is arbitrary. 
\vspace{1ex}

Example of a control file:
\vspace{1ex}
\begin {tabbing}
Struct>   \= XXXXXXXXXXXXXXX  \=  \kill
\> {\tt PATTERNFILE}  eddy.in \>  **\\
\> {\tt WEIGHTFILE}   eddy.dat\\
\> {\tt XSIZE} 18     \> $\leftarrow$\\
\> {\tt YSIZE} 18     \> $\leftarrow$\\
\> {\tt COMPONENTS} 8 \> $\leftarrow$\\
\> {\tt PATTERNS} 47  \> **\\
\end {tabbing}
\vspace{1ex}

For creation of a network file you need at least the statements marked 
$\leftarrow$ and for the .pat file additionally the statements marked **.\\
 Omitting the {\tt WEIGHTFILE} will initialize the weights of the network 
with 0.

The {\tt WEIGHTFILE} is a simple ASCII file, containing the weight vectors 
row by row.

The {\tt PATTERNFILE} contains in each line the components of a pattern.
\vspace{1ex}

If convert2snns has finished  the conversion  it will ask for the name of the
network and pattern files to be saved.

\section {Feedback-gennet}
\index{Tools!Feedback-gennet}

The program {\tt feedback-gennet} generates network definition files for fully
recurrent networks of any size. This is not possible by using bignet.
\vspace{1ex}

The networks have the following structure:
\vspace{1ex}

- input layer with no intra layer connections\\
- fully recurrent hidden layer\\
- output layer: connections from each hidden unit to each output unit \\
\verb#AND#\\
optionally fully recurrent intra layer connections in the output layer \\
\verb#AND#\\
optionally feedback connections from each output unit to each hidden unit.
\vspace{1ex}    

The activation function of the output units can be set to sigmoidal or linear.
 All weights are initialized with 0.0. Other initializations should be
performed by the init functions in SNNS.

Synopsis: {\tt feedback-gennet}

example:

\begin{tabbing}
XXXX \= XXXXXXXXXXXXXX \= XXXXXXXXXXXXXXXX \= \kill
\> {\tt unix> }feedback-gennet\\
\> \\
produces\\
\> \\
\> Enter $\#$ input units: \> 3\\
\> Enter $\#$ hidden units: \> 3\\
\> Enter $\#$ output units: \> 1\\
\> INTRA layer connections in the output layer \> \> (y/n) :n\\
\> feedback connections from output to hidden units \> \> (y/n) :n\\
\> Linear output activation function \> \> (y/n) :n\\
\> Enter name of the network file: xor-rec.net\\
\> working...\\
\> generated xor-rec.net\\
\end {tabbing}

\section {Mkhead}
\index{Tools!Mkhead}

This program writes a SNNS pattern file header to stdout. This program can be used 
together with mkpat and mkout to produce pattern files from raw files in a 
shell script.   
\vspace{1ex}

Synopsis: {\tt mkhead} $<$pats$>$ $<$in\_units$>$ $<$out\_units$>$

where:
\vspace{1ex}
\begin {tabbing}
XXXX \= xxxxxxxxxxxxxxxxx \= \kill
\> {\tt pats} \> are the number of patterns in the file\\
\> {\tt in\_units} \> are the number of input units in the file\\
\> {\tt out\_units} \> are the number of output units in the file
\end {tabbing}

\section {Mkout}
\index{Tool!Mkout}

This program writes a SNNS output pattern to stdout. This program can be used 
together with mkpat and mkhead to produce pattern files from raw files in 
a shell script.

Synopsis: {\tt mkout }$<$units$>$ $<$active\_unit$>$

where:
\vspace{1ex}
\begin {tabbing}
XXXX \= xxxxxxxxxxxxxxxxxx \= \kill
\> {\tt units} \> is the number of output units\\
\> {\tt active\_unit}  \> is the unit which has to be activated
\end {tabbing}

\section {Mkpat}
\index{Tools!Mkpat}

The purpose of this program is to read a binary 8-Bit file from the stdin and
writes a SNNS pattern file entry to stdout. This program can be used together 
with mkpat and mkout to produce pattern files from raw files in a shell script.

Synopsis: {\tt mkpat} $<$xsize$>$ $<$ysize$>$

where:
\vspace{1ex}
\begin {tabbing}
XXXX \= xxxxxxxxxxxxxxxxxx \= \kill
\> {\tt xsize         } \> is the xsize of the raw file\\
\> {\tt ysize         } \> is the ysize of the raw file
\end {tabbing}

\section {Netlearn}
\index{Tools!Netlearn}

This is a SNNS kernel backpropagation test program. It is a demo for
using the SNNS kernel interface to train networks.

Synopsis: {\tt netlearn}

example:

\begin {tabbing}
XXXX \= XXXXXXXXXXXXXX \= XXXXXX \= \kill
\> {\tt unix> }netlearn\\
\> \\
produces\\
\> \\
\> SNNS 3D-Kernel V 4.0\\
\> ---Network learning---\\
\> \\
\> Filename of the network file: letters\_untrained.net\\
\> Loading the network...\\
\> \\
\> Network name: letters\\
\> No. of units: \> 71\\
\> No. of input units: \> 35\\
\> No. of output units: \> 26\\
\> No. of sites: \> 0\\
\> No. of links: \> 610\\
\> \\
\> Learning function: \> Std\_Backpropagation\\
\> Update function: \> Topological\_Order\\
\> \\
\> Filename of the pattern file: letters.pat\\
\> loading the patterns...\\ 
\> \\
\> Number of pattern: \> 26\\
\> \\
\> The learning function  Std\_Backpropagation needs 2 input parameters:\\
\> Parameter [1]: \> 0.6\\
\> Parameter [2]: \> 0.6\\
\> Choose number of cycles: 250\\
\> \\
\> Shuffle patterns (y/n) \> n\\
\> Shuffling of patterns disabled\\
\> \\
\> learning...\\
\end {tabbing} 

\section {Netperf}
\index{Tools!Netperf}

This is a benchmark program for SNNS. Propagation and backpropagation tests 
are performed.

Synopsis: {\tt netperf}

example:
\begin {tabbing}
XXXX \= XXXXXXXXXXXXXXXX \= XXXXXX \= \kill
\> {\tt unix> } netperf\\
\> \\
produces\\ 
\> \\
\> SNNS 3D-Kernel V4.0
\> --- Benchmark Test ---
\> \\
\> Filename of the network file: nettalk.net\\
\> loading the network...\
\> Network name: nettalk1\\
\> No. of units: \> 349\\
\> No. of input units: \> 203\\
\> No. of ouput units: \> 26\\
\> No. of sites: \> 0\\
\> No. of links: \> 27480\\
\> \\
\> Learningfunction: \> Std\_Backpropagation\\
\> Updatefunction: \> Topological\_Order\\
\> \\
\> Do you want to benchmark\\
\> Propagation \> [1] or \\
\> Backpropagation \> [2]\\
\> Input: \> 1\\
\> \\
\> Choose no. of cycles\\
\> Begin propagation...\\
\> \\
\> No. of units updated: \> 34900\\
\> No. of sites updated: \> 0\\
\> No. of links updated: \>2748000\\
\> CPU Time used: \> 3.05 seconds\\
\> \\
\> No. of connections per second (CPS) : 9.0099e+05
\end {tabbing}

\section{Pat$\_$sel}
\index{Tools!Pat$\_$sel}

Given a pattern file and a file which contains numbers, {\tt pat\_sel}
produces a new pattern file which contains the subset of the first
one.  This pattern file consists of the patterns whose numbers are
given in the number file.


Synopsis: {\tt pat\_sel} $<$number file$>$ $<$input pattern file$>$ $<$output pattern file$>$

Parameters:
\vspace{1ex}
\begin {tabbing}
XXXXXXXXXXXXXXXXXXXX \= XXXXXXXXXX \= \kill
{\tt <number file>} \> ASCII file which contains positive integer\\ 
\> numbers (one per line) in ascending order.\\
{\tt <input pattern file>} \> SNNS pattern file.\\
{\tt <output pattern file>} \> SNNS pattern file which contains the selected\\
\> subset (created by {\tt pat\_sel})
\end {tabbing}
{\tt Pat\_sel} can be used to create a pattern file which contains only the 
patterns that were classified 'wrong' by the neural network.  
That is why a `result file' has to be created using SNNS. 
The result file can be analyzed with the tool analyze. 
This 'number file' and the corresponding 'pattern file' are used by 
pat\_sel. The new 'pattern file' will be created.



\section{Snns2c}
\index{Tools!snns2c}

Synopsis: {\tt snns2c} $<$network$>$ $[<$C-filename$>$
$[<$function-name$>]$ $]$ 

where:

\vspace{1ex}
\begin{tabular}{l l}
  {\tt $<$network$>$} & is the name of the SNNS network file,\\
  {\tt $<$C-filename$>$ }& is the name of the output file\\
  {\tt $<$function-name$>$ }& is the name of the procedure in the
   application.
\end{tabular}

This tool compiles an SNNS network file into an executable C source.
It reads a network file {\tt $<$network.net$>$} and generates a C source
named {\tt $<$C-filename$>$}. The network can be called now as a function
named {\tt $<$function-name$>$}. If the parameter  {\tt
$<$function-name$>$} is missing, the name of {\tt $<$C-filename$>$} is
taken without the ending ``*.c''. If this parameter is also missing,
the name of the network file is chosen and fitted with a new
ending for the output file. This name without ending is also used for
the function name.

It is not possible to train the generated net, SNNS has to be used for
this purpose.  After completion of network training with SNNS, the
tool {\sc snns2c} is used to integrate the trained network as a C
function into a separate application.

This program is also an example how to use the SNNS kernel interface
for loading a net and changing the loaded net into another format.  All
data and all SNNS functions -- except the activation functions -- are
placed in a single C function. 

{\bf Note:\\} {\sc Snns2c} does not support sites. Any networks created
with SNNS that make use of the site feature can not be converted to C
source by this tool. Output functions are not supported, either.
\vspace{0.3cm}

\noindent
The program can translate the following network-types:
\begin{itemize}
\item Feedforward networks trained with Backpropagation and all 
      variants of it like Quickprop, RPROP etc. 
\item Radial Basis Functions
\item Partially-recurrent Elman and Jordan networks
\item Time Delay Neural Networks (TDNN)
\item Dynamic Learning Vector Quantisation (DLVQ)
\item Backpropagation Through Time (BPTT, QPTT, BBPTT)
\item Counterpropagation Networks
\end{itemize}

While the use of SNNS or any parts of it in commercial applications
requires a special agreement/licensing from the developers, the use
of trained networks generated with {\sc snns2c} is hereby granted without
any fees for any purpose, provided proper academic credit to the SNNS 
team is given in the documentation of the application.

\subsection{Program Flow}

Because the compilation of very large nets may require some time, the
program outputs messages, indicating which state of compilation is
passed at the moment.

\begin{description}
\item[{ loading net...}] the network file is loaded with the function
  offered by the kernel user interface.

\item[{ dividing net into layers ...}] all units are grouped into layers
  where all units have the same type and the same activation function.
  There must not exist any dependencies between the units of the
  layers except the connections of SPECIAL HIDDEN units to themselves
  in Elman and Jordan networks or the links of the BPTT-networks.

\item[{ sorting layers...}] these layers are sorted in topological
  order, e.g. first the input layer, then the hidden layers followed
  by the output layers and at last the special hidden layers.  A layer
  which has sources in another layer of the same type is updated later
  as the source layer.

\item[{ writing net...}] selects the needed activation functions and writes
  them to the C-source file. After that, the procedure for pattern
  propagation is written.
\end{description}


\subsection{Including the Compiled Network in the Own Application}

\paragraph{Interfaces:}

All generated networks may be called as C functions. This functions
have the form:\\
\centerline{\tt int{\em function-name}(float *in, float *out, int init)} 
where {\tt in} and {\tt out} are pointers to the input and output
arrays of the network. The init flag is needed by some network types
and it's special meaning is explained in \ref{special}. The function
normally returns the value 0 (OK). Other return values are explained in
section \ref{special}.

The generated C-source can be compiled separately. To use the network
it's necessary to include the generated header file (*.h) which is
also written by {\sc snns2c}. This header file contains a
prototype of the generated function and a record which contains
the number of input and output units also.

\paragraph{Example:}

If a trained network, was saved as ``myNetwork.net'' and compiled
with 
\begin{center}
{\tt snns2c myNetwork.net} 
\end{center}
then the generated Network can be compiled with
\begin{center}
{\tt gcc -c myNetwork.c}
\end{center}

To include the network in your own application the header file must be
included. There should also two arrays being provided, one for the
input and one for the output of the network. The number of inputs and
outputs can be derived from a record in the header file. This struct
is named like the function which contains the compiled network and has
the suffix REC to mark the record. So the number of input units is
determined with {\tt myNetworkREC.NoOfInput} and the number of outputs
with {\tt myNetworkREC.NoOfOutput} in this example.  Hence, your own
application should contain:

$\vdots$
\begin{verbatim}
#include "myNetwork.h"
\end{verbatim}
$\vdots$
\begin{verbatim}
float *netInput, *netOutput; /* Input and Output arrays of the Network */
netInput  = malloc(myNetworkREC.NoOfInput  * sizeof(float));
netOutput = malloc(myNetworkREC.NoOfOutput * sizeof(float));
\end{verbatim}
$\vdots$
\begin{verbatim}
myNetwork(netInput, netOutput, 0)
\end{verbatim}
$\vdots$\\
Don't forget to link the object code of the network to your application

\subsection{Special Network Architectures}
\label{special}

Normally, the architecture of the network and  the numbers of the
units are kept. Therefore a dummy unit with the number 0 is inserted in
the array which contains the units. Some architectures are translated
with other special features.

\paragraph{TDNN:}
Generally, a layer in a time delay neural network consists of feature units and
their delay units. {\sc snns2c} generates code only containing
the feature units. The delay units are only additional activations in
the feature unit. This is possible because every delay unit has the
same link weights to it's corresponding source units as its feature
unit.

So the input layer consists only of its prototype units, too. Therefore
it's not possible to present the whole input pattern to the
network. This is not necessary because it can be presented step by
step to the inputs. This is useful for a real-time application,
with the newest feature units as inputs. To mark a new sequence the
{\em init}-flag (parameter of the function) can be set to 1. After
this, the delays are filled when the init flag is set to 0 again. 
To avoid meaningless outputs the function returns NOT\_VALID until the
delays are filled again.

There is a new variable in the record of the header file for TDNNs. It
is called ``MinDelay'' and is the minimum number of time steps which
are needed to get a valid output after the {\em init}-flag was set.

\paragraph{CPN:} Counterpropagation doesn't need the output layer. The
output is calculated as a weighted sum of the activations of the
hidden units. Because only one hidden unit has the activation 1 and
all others the activation 0, the output can be calculated with the
winner unit, using the weights from this unit to the output.

\paragraph{DLVQ:} Here no output units are needed either. The output is
calculated as the bias of the winner unit.

\paragraph{BPTT:}
If all inputs are set to zero, the net is not initialized. This
feature can be chosen by setting the {\em init}-flag.


\subsection{Activation Functions}

\paragraph{Supported Activation Functions:}
Following activation functions are implemented in {\sc snns2c}

\begin{center}
\begin{tabular}{| l | l |}
\hline
\multicolumn{2}{|c|}{\bf Supported Activation Functions}\\
\hline\hline
Act\_Logistic&              Act\_StepFunc\\
Act\_Elliott &              Act\_Identity\\            
Act\_BSB &                  Act\_IdentityPlusBias\\    
Act\_TanH&                  Act\_RBF\_Gaussian\\       
Act\_TanHPlusBias&          Act\_RBF\_MultiQuadratic\\ 
Act\_TanH\_Xdiv2 &          Act\_RBF\_ThinPlateSpline\\
Act\_Perceptron&            Act\_TD\_Logistic\\        
Act\_Signum&                Act\_TD\_Elliott\\         
Act\_Signum0 &\\
\hline                    
\end{tabular}
\end{center}

\paragraph{Including Own Activation Functions:}
The file "tools/sources/functions.h" contains two arrays: One array
with the function names (ACT\_FUNC\_NAMES) and one for the macros
which represent the function (ACT\_FUNCTIONS). These macros are
realized as character strings so they can be written to the generated
C-source.

The easiest way to include an own activation function is to write the
two necessary entries in the first position of the arrays. After that
the constant ``ActRbfNumber'' should be increased. If a new Radial Basis
function should be included, the entries should be appended at the end
without increasing ActRbfNumber. An empty string ("") should still be the last
entry of the array Act\_FUNC\_NAMES because this is the flag for the end
of the array.

\subsection{Error Messages}

Here is the list of possible error messages and their brief
description.

\begin{description}
\item[{ not enough memory}:] a dynamic memory allocation failed.

  {\bf Note:}\\ The C-code generated by snns2c that describes the
  network (units and links) defines one unit type which is used for
  all units of the network. Therefore this unit type allocates as many
  link weights as necessary for the network unit with the most input
  connections. Since this type is used for every unit, the necessary
  memory space depends on the number of units times size of the
  biggest unit.

  In most cases this is no problem when you use networks with moderate
  sized layers. But if you use a network with a very large input
  layer, your computer memory may be to small. For example, an $n-m-k$
  network with $n > m > k$ needs about $n*(n+m+k) * (sizeof(float) +
  sizeof(void*))$ bytes of memory, so the necessary space is of
  $O(n^2)$ where n is the number of units of the biggest layer.

  We are aware of this problem and will post an improved version of
  snns2c as soon as possible.

\item[{ can't load file}:]  SNNS network-file wasn't found.

\item[{ can't open file}:] same as can't load or disk full.

\item[{ wrong parameters}:] wrong kind or number of parameters.

\item[{ net contains illegal cycles}:] there are several possibilities:
  \begin{itemize}
  \item a connection from a unit which is not a SPECIAL HIDDEN unit 
        to itself.
  \item two layers are connected to each other when not exactly
     one of them is SPECIAL HIDDEN.
  \item cycles over more than two layers which don't match the architecture
     of Jordan networks.
  \end{itemize}
  BPTT-networks have no restrictions concerning links.

\item[{ can't find the function {\em actfunc}}:] the activation function 
  {\em actfunc} is not supported.

\item[{ net is not a CounterPropagation network}:]
Counter\-pro\-paga\-tion-networks need a\\ special architecture: one input, one
output and one hidden layer which are fully connected.

\item[{ net is not a Time Delay Neural Network}:]  
The SNNS TDNNs have a very special architecture. They should be
generated by the {\sc bignet}-tool. In other cases there is no guaranty for
successful compilation. 

\item[{ not supported network type}:]  There are several network
types which can't be compiled with the {\sc snns2c}. The {\sc
  snns2c}-tool will be maintained and so new network types will be implemented.

\item[{ unspecified Error}:] should not occur, it's only a feature
for user defined updates.

\item[{ unknown error code : {\em number}}:] must not occur, please
  report to the  SNNS-Team.
\end{description} 
