3.   Attrasoft PolyApplet63
    3.1   Class Library Name
    3.2   Interface
    3.3   Class Library Overview
    3.4   Link To Class Library
    3.5   Training and Recognition File Format
    3.5.1   Data File Formats
    3.5.2   Limits
    3.6   Setting Up PolyApplet Output Files
    3.6.1   Position of a Digit in a String
    3.6.2   Output File Format
    3.7   Setup Symmetry
    3.7.1   Setup Symmetry Parameters
    3.8   Neural Commands
    3.8.1   Binary and Polytomous Recognition Commands
    3.8.2   Classification and Distribution
    3.8.3   1-Neuron-1-Class Classifications/Distributions
    3.8.4   Training, Retraining and Recognition
    3.8.5   Array Commands
    3.8.6   Search Commands
    3.9   Test Input File Format
    3.10   Messages
    3.11   Example Class
    3.12  Common Errors

     

    3.   Attrasoft PolyApplet63

    This chapter introduces the interface for the neural layer component of the Attrasoft PolyApplet. The class library in PolyApplet is PolyApplet63.

    3.1   Class Library Name

    The neural layer class library is:
     

       Attrasoft.PolyApplet63.PolyApplet63.


    The class in this library will be:
     

       Attrasoft.PolyApplet63.PolyApplet63.PolyApplet63.


    3.2   Interface

    PolyApplet63 implements the following interface:
     

      interface I_PolyApplet63
       {
         //1. Neural Net
          void setNeuralNet(int x);
          int getNeuralNet();
          bool getNeuralNetStatus();
          void setN( int n);
          int getN( );

          //2. Parameter Section
          void setRotationType(int x);
          int getRotationType();

          void setTranslationType(int x);
          int getTranslationType();

          void setScalingType(int x);
          int getScalingType();

          void setSensitivity(int x);
          int getSensitivity();

          void setBlurring(int x);
          int getBlurring();

          void setInternalThreshold(int x);
          int getInternalThreshold();

          void setSegmentSize(int x);
          int getSegmentSize();

          void setImageType(int x);
          int getImageType();

          //3. Files:
          void setTrainFile( string aFile);
          string getTrainFile( );

          void setRecognitionFile( string aFile);
          string getRecognitionFile( );

          void setOutputFile( string aFile);
          string getOutputFile( );

          void setHelpFile( string aFile);
          string getHelpFile( );

          bool testInput();  //Test Input Files

          bool openTrainFile ();
          bool openRecognitionFile ();
          bool openOutputFile ();

          //4. Symmetry and Breaker
          // Symmetry
         bool setSymDimension (int symStart, int symEnd, int xDimension, int yDimension);
          void deleteSymDimension () ;
          bool setSymmetry (int aSym);
          void deleteSymmetry ();
          int getSymmetry();

          //final int   SymxTranslation1D = 1;
          //final int   SymxScaling1D  = 2;
          //final int   SymxyTranslation2D = 3;
          //final int   SymxyScaling2D = 4;
          //final int   SymzRotate2D  = 5;
          //final int   SymzRotatexyScaling2D = 6;

          int getSymmetryStart();
          int getSymmetryEnd();
          int getSymmetryXDimension();
          int getSymmetryYDimension() ;

        bool setLineBreaker(int line2, int line3, int line4, int line5 );
          void deleteLineBreaker();
          int getLineBreaker1();
          int getLineBreaker2();
          int getLineBreaker3();
          int getLineBreaker4();

          //5. Search
          bool train ( char [] trainArray  );
          bool train () ;
          bool retrain ( char [] reTrainArray  );
          bool retrain () ;
          long match(  char [] matchArray);

          //6. classification

          //6A. Binary Neural Commands
          bool classification() ;
          bool distribution () ;
          bool classification1N1C() ;
          bool distribution1N1C () ;

          bool Recognition_classification() ;
          bool Recognition_classification1N1C() ;
          long Recognition_classification1N1C(char[] b) ;

          bool Recognition_distribution () ;
          bool Recognition_distribution1N1C () ;
          long Recognition_distribution1N1C (char[] b) ;

          bool Recognition_localMinima (int repeat) ;

          //6B. Polytomous Neural Commands
           bool polyClassification() ;
          bool polyDistribution () ;
          bool polyClassification1N1C() ;
          bool polyDistribution1N1C () ;

          bool polyRecognition_classification() ;
          bool polyRecognition_classification1N1C() ;
          long polyRecognition_classification1N1C(char[] b) ;

          bool polyRecognition_distribution () ;
          bool polyRecognition_distribution1N1C () ;
          long polyRecognition_distribution1N1C (char[] b) ;

       }


    3.3   Class Library Overview

    Setting up a neural net means to select a neural network size. For example, select a neural network of 100 neurons. The first group of commands deals with how to set up a neural net:
     

       void setNeuralNet(int x);
       int getNeuralNet();
       bool getNeuralNetStatus();
       void setN( int n);
       int getN( );


    The neural net layer class library has several parameters. The next group of commands deals with how to set up the parameter:
     

       void setRotationType(int x);
       int getRotationType();

       void setTranslationType(int x);
       int getTranslationType();

       �


    The neural net will use several files. Please refer to Attrasoft ABM for Windows for the files used. The next group of commands deals with how to assign or open the neural files:
     

       void setTrainFile( string aFile);
       string getTrainFile( );

       void setRecognitionFile( string aFile);
       string getRecognitionFile( );

       �


    The next group of commands deals with Symmetries and Breakers; again, please refer to the software ABM 2.7 for details.

    The Attrasoft ImageFinder uses the following Array commands:
     

       bool train ( char [] trainArray  );
       bool train () ;
       bool retrain ( char [] reTrainArray  );
       bool retrain () ;
       long match(  char [] matchArray);


    The binary neural net commands are:
     

       bool classification() ;
       bool distribution () ;
       bool classification1N1C() ;
       bool distribution1N1C () ;

       bool Recognition_classification() ;
       bool Recognition_classification1N1C() ;
       long Recognition_classification1N1C(char[] b) ;

       bool Recognition_distribution () ;
       bool Recognition_distribution1N1C () ;
       long Recognition_distribution1N1C (char[] b) ;

       bool Recognition_localMinima (int repeat) ;


    The multi-valued neural network commands are:
     

       bool polyClassification() ;
       bool polyDistribution () ;
       bool polyClassification1N1C() ;
       bool polyDistribution1N1C () ;

       bool polyRecognition_classification() ;
       bool polyRecognition_classification1N1C() ;
       long polyRecognition_classification1N1C(char[] b) ;

       bool polyRecognition_distribution () ;
       bool polyRecognition_distribution1N1C () ;
       long polyRecognition_distribution1N1C (char[] b) ;


    3.4   Link To Class Library

    To include the class library in the project:

    • Right click �References� in the solution explorer;
    • Browse to find �c:\polyapplet63\PolyApplet63.dll�;
    • Highlight it and click �OK� button.


    To use the class library, add:
     

      using Attrasoft.PolyApplet63.PolyApplet63;


    To declare an object, add:
     

      public Attrasoft.PolyApplet63.PolyApplet63 x
      = new Attrasoft. PolyApplet63.PolyApplet63 ();


    Now PolyApplet63 object, x, is ready to use.

    3.5   Training and Recognition File Format

    The file commands are:
     

      void setTrainFile( string aFile);
      string getTrainFile( );

      void setRecognitionFile( string aFile);
      string getRecognitionFile( );

      void setOutputFile( string aFile);
      string getOutputFile( );

      void setHelpFile( string aFile);
      string getHelpFile( );

      bool testInput();  //Test Input Files


    You can train your neural net in two ways:
     

    • Training file; or
    • Training array.


    After training, you can recognize a pattern in two ways:
     

    • Recognition file; or
    • Recognition array.


    If you choose to train your neural net with a training file, or recognize patterns in a recognition file, the above commands will let you specify these files. Similarly, you can set the output file, which contains the results after neural computation, and the help file, which will be the help file in your neural software.

    The training and the recognition files must follow the Attrasoft formats. An example of a training file is:

       
      *
       5x7 Character Recognition: Training File
        Add your data at the end
       *

      46

      10000000000
        01000
        10100
        10100
        01000
        00000
        00000
        00000
      10000000000
        01000
        10100
        10100
        10100
        01000
        00000
        00000


    The 10 neurons, 10000000000, are called classification-neurons. These classification neurons together represent a classification. The 35 neurons,
     

        01000
        10100
        10100
        01000
        00000
        00000
        00000


    are called pattern-neurons. These pattern neurons together represent a pattern.
     

    An example of a recognition file is:
     

      *
      5x7 Character Recognition : Recognition File
      *

      xxxxxxxxxxx
        00100
        01010
        01010
        01010
        01010
        00100
        00000


    3.5.1   Data File Formats

    To make a long story short, in the training file, you will:
     

    • Put an '*' in the first line;
    • Put an '*' in the second line;
    • Write the number of neurons in the third line;
    • Enter the training data to the fourth line and downward.


    In the recognition file, you will:
     

    • Put an '*' in the first line;
    • Put an '*' in the second line;
    • Starting from the third line, enter the recognition data with the unknown neurons marked as 'x'.


    The two files must be prepared in the text file format. The training file has three sections:
     

    • Comment Section;
    • Number of variables;
    • Data Section.


    The recognition file has two sections:
     

    • Comment Section;
    • Data Section.


    Part 1 of the Training File: Comment Section
     

      The comment section starts with an "*" and ends with another "*". The purpose of this section is to document your data:
       
      • Give a description of the data;
      • Specify the data set used;
      • . . .


      Example:

        *
        Title:  5 x7 character recognition
        Data:   0, 1, ..., 9
        *


    Note: the PolyApplet will ignore this section. This section is for your remarks only.

    Part 2 of the Training File: Number of Neurons
     

      This section has a single integer, which will tell the PolyApplet how many neurons you will use.
      In the 5x7 character recognition example, each 5x7 character takes 35 neurons, and the number of classes is 11, giving a total of 35 + 11 = 46 neurons.


    Part 3 of the Training File: Data Section
     

      This section contains the data.


    Part 1 of the Recognition File: Comment Section
     

      This section is the same as the comment section of the training file.


    Part 2 of the Recognition File: Data Section
     

      This section is the same as the data section of the training file, however, each pattern contains unknown bits, xxx...xxx. PolyApplet will convert the unknown bits to a string of 0's, 1's, ... and 9's.
      The rules for the recognition files are:

      (1) The unknown digits in a recognition file must be marked as 'x';
      (2) The unknown digits in a recognition file must stay together;
      (3) The unknown digits in a recognition file must all be in the same positions.

      The following test pattern is wrong because the x's are separated:

         
         100 xx11 xx10,


      The following test pattern is wrong because y's are illegal characters:
       

        100 yyyy 0110,


      The following test pattern is wrong because the x's are not in the same positions:
       

        100 xxxx 0110,
        100 00xx xx10.


       If you want the PolyApplet to recognize:
       

        100 xxxx 0110,
        100 00xx xx10,


      you have to run it twice; the first time with the recognition pattern:
       

        100 xxxx 0110,


      and the second time with the pattern:

         
         100 00xx xx10.


    3.5.2   Limits
     

    • If you are using the training files and recognition files, the neuron states are limited to {0, 1, ..., 9}.
    • If your neuron states have more than 10 levels, you have to train the PolyApplet with arrays, instead of files. We will explain this later.
    • Also, the maximum number of neurons is 10,000, for this particular software.  The minimum number of neurons is 6.


    3.6   Setting Up PolyApplet Output Files

    3.6.1   Position of a Digit in a String

    Let a string be 101, then the position of the first digit is 0; the position of the second digit is 1; and the position of the third digit is 2, ...
     

       position: 012,
       pattern:  101.
    Similarly, the position of another pattern 1010 1100 is:
     
       position: 0123 4567,
       pattern:  1011 1100.


    3.6.2   Output File Format

    The line-breaker commands are:
     

      public boolean setLineBreaker(int line2, int line3, int line4, int line5 )
      public void deleteLineBreaker( )
      public int getLineBreaker1()
      public int getLineBreaker2()
      public int getLineBreaker3()
      public int getLineBreaker4()


    If no output format is given, the default will print one pattern per line.

    If your recognition pattern is long, or they are 2-dimensional, you might want to change this default format. Inserting line breakers will do just that. PolyApplet allows you to insert up to 4 line breakers. To insert the line breakers, you must specify the positions of the line breakers. Suppose you want the output to look like this:
     

       111
       0000
       11111
       000000
       1111111


    then call setLineBreaker ( 3, 7, 12, 18 ). The position of the first digit is 0; the position of the second digit is 1; and the position of the third digit is 2. Note that after "111", the next position is 3, and 3 is the first parameter in setLineBreaker ( 3, 7, 12, 18 ), meaning a new line starts after "111".  The default values are all -1, meaning no line breakers.

    PolyApplet allows the output neurons to be printed on five lines. However, if line 2 and line 3, (or line 3 and line 4) have an equal length, all the rest of the lines will also have the same length. For example, to change the output-vector to:
     

       1111
       000
       111
       000
       111
       000
       111
      000
       1,


    call setLineBreaker ( 4, 7, 10, 13 ).

    3.7   Setup Symmetry

    The Symmetry commands are:
     

       bool setSymDimension (int symStart, int symEnd, int xDimension, int yDimension);
       void deleteSymDimension () ;
       bool setSymmetry (int aSym);
       void deleteSymmetry ();
       int getSymmetry();
       
          public const int   SymxTranslation1D = 1;
          public const int   SymxScaling1D  = 2;
          public const int   SymxyTranslation2D = 3;
          public const int   SymxyScaling2D = 4;
          public const int   SymzRotate2D  = 5;
          public const int   SymzRotatexyScaling2D = 6;


       int getSymmetryStart();
       int getSymmetryEnd();
       int getSymmetryXDimension();
       int getSymmetryYDimension() ;


    Symmetry means that after you transform the pattern, both the original pattern and the transformed pattern belong to the same class. The transformation includes:
     

    • Translation
    • Rotation
    • Scaling
    • Oblique Observation
    • Different light intensity
    • Combinations of basic symmetries


    For example, a picture of a person in the middle of a page and the same person near the edge of the paper represents the same person. Almost all images have some sort of symmetry. Please study Symmetry in ABM 2.7.

    PolyApplet supports one-dimensional and two-dimensional patterns.

    One-dimensional patterns may have the following symmetries:
     

    • Translation (1);
    • Scaling (2).


    Two-dimensional patterns may have the following symmetries:
     

    • Translation (3);
    • Scaling (4);
    • Rotation (5);
    • Scaling and Rotation (6).


    3.7.1   Setup Symmetry Parameters

    Symmetries only apply to the pattern-neurons. In general, the classification-neurons do not have any symmetry.

     To specify the symmetry, you have to specify:
     

    • Where is the symmetry ?
    • What symmetry ?


    Where:
     

      The position of a pattern and the dimension tell "where":

      Position: where does it start, and where does it end:
      Dimension: 1-dimension or 2-dimension.

      The function, public boolean setSymDimension (int symStart, int symEnd, int xDimension, int yDimension), specifies:

      where symmetry starts
      where symmetry ends
      the x-dimension of  the symmetry
      the y-dimension of  the symmetry

      If you do not specify the symmetry, the default values are -1, meaning no symmetry. Please refer to the last section for the position of a pattern.


    What:
     

      The function, public boolean setSymmetry (int aSym), with the following parameters:
       
          public const int   SymxTranslation1D = 1;
          public const int   SymxScaling1D  = 2;
          public const int   SymxyTranslation2D = 3;
          public const int   SymxyScaling2D = 4;
          public const int   SymzRotate2D  = 5;
          public const int   SymzRotatexyScaling2D = 6;


      will specify the symmetry as follows:
       

      • 1-D Translation (1);
      • 1-D Scaling (2);
      • 2-D Translation (3);
      • 2-D Scaling (4);
      • 2-D Rotation (5);
      • 2-D Scaling and Rotation (6).


    The Rotation symmetry automatically implies the Translation symmetry, so does the Scaling symmetry.

    Example   The 4-Digit Shifter Problem (See ABM 2.7) has 1-dimensional x-translation symmetry. The class-neurons take digits from 0 to 2, and the pattern-neurons take digits from 3 to 10. The x-dimension is 8 and there is no y-dimension. The position is shown as follows:
     

       Position 012 3456  789 10
       Vector  100 0011  011 0

      Call setSymDimension (3, 10, 8, -1), meaning

       Symmetry starts at 3
       Symmetry ends at 10
       x-dimension is  8
       y-dimension is  -1

      and call setSymmetry (1), meaning: x-translation symmetry.

      Note the relation:

        x-dimension = Symmetry end - Symmetry start + 1 , or
       8 = 10 - 3 + 1.


    Example    The  '5 by 7' Character Recognition Problem (See ABM 2.7) has x- and y-translation symmetry. Let a pattern be:

       
         01000 00000 0
           00100
           01100
           00100
           00100
           00100
           00100
           01110


      The class-neurons take digits from 0 to 10 and the pattern-neurons take digits from 11 to 45.
      The x-dimension is 5 and the y-dimension is 7. Call setSymDimension (11, 45, 5, 7), meaning
       

         Symmetry starts at  11
         Symmetry ends at  45
         x-dimension is   5
         y-dimension is   7


      and call setSymmetry (3), meaning 2-D translation symmetry.


    Note the relation:

     x-dimension * y-dimension = Symmetry end - Symmetry start + 1,
    or 5 * 7 = 45 - 11 + 1.

    When you specify the Translation symmetry, the numbers must satisfy the following conditions:

    1-D: x-dimension = Symmetry end - Symmetry start + 1;
    2-D: x-dimension * y-dimension
    = Symmetry end - Symmetry start + 1.

    When there are errors in the specification, an error message will be printed on a Rich Text Box.

    3.8   Neural Commands

    3.8.1   Binary and Polytomous Recognition Commands

    The recognitions commands are divided into four categories:
     

    • Training
    • Array Matching commands (for the ImageFinder)
    • Binary commands
    • Multi-valued commands


    The training commands are the same for all.

    3.8.2   Classification and Distribution

    All neural computation starts with training. Training means the PolyApplet learns the patterns from the training file.

    Recognition comes after training. Recognition means the PolyApplet classifies the patterns in the recognition files.

    There are two basic commands:

    Classification -------- the Hopfield Model;
    Distribution   --------- the Boltzmann Machine.

    The output of the computation goes to the output file.

    The command, "Distribution" presents you with a distribution, which is a list of all possible classifications and how valuable the PolyApplet thinks each prediction is via a confidence number. This number is similar to the score in an Internet Search Engine: the higher that number, the more confidence the PolyApplet has in that distribution.

    The command, "Classification" presents you with a classification, and a confidence number. This number is similar to the score in an Internet Search Engine: the higher that number, the more confidence the PolyApplet has in that classification.

    Each of the above commands has two phases:
     

    • Training; and
    • Recognition.


    In the training phase, the training file is imposed upon a neural network to force the network to remember the pattern of the training data. A neural network can remember the training pattern by adjusting its internal synaptic connections.

    In the recognition phase, a part of the input data in the recognition file is not known. The neural network, based on its internal synaptic connections, will determine the unknown part.

    A typical problem for a neural network to solve is the classification problem. The data is a set of doublets: (pattern, class). In the training phase, the network is taught which pattern belongs to which class. In the recognition phase, only the patterns are given to the network, and the network decides the classification of the patterns. Alternatively, when a part of a pattern and a classification are given, or just a part of a pattern is given, the network is asked to complete the pattern.

    Click commands "Classification" or "Distribution", and you can expect three possibilities for each recognition pattern:
     

      Correct Classification: this is usually the case when the Boltzmann Machine assigns one predominate probability to one of the output possibilities.

      Incorrect Classification: this is usually the case when: the Boltzmann Machine assigns a predominate probability to more than one configuration; or the relative probability is "small". It is hard to define "small" here because it depends on the problem, but for a given problem, an experienced user will know what is "small".

      No Classification: this is usually the case when the Boltzmann Machine can find little correlation in the test pattern, based on the current training. In such a case, "No classification" is printed in the output data file.


    3.8.3   1-Neuron-1-Class Classifications/Distributions

    There is no restriction on how to represent a classification using classification neurons. The most common method of representing a class is to use one neuron for each class.  Among class neurons, one of the neurons is '1'; all others are '0':
     

      100 ... 00
      010 ... 00
      001 ... 00
      ...
      000 ... 10
      000 ... 01


    Here each "1" represents a class classification. Of course, you can choose any way to represent a class.

    We will call the above representation "1 neuron for 1 class" or 1N1C representation. If you do choose 1N1C representations, we have two more commands:
     

      public boolean polyClassification1N1C()
      public boolean polyDistribution1N1C ()


    The reason to offer these 1N1C commands is that they are 50% to 100% faster than the standard commands, especially for large problems.

    If your problem is reasonably large, meaning:
     

    • Thousands of training patterns; or
    • Thousands of neurons; or
    • Combined symmetries;
    then you should encode your problem with 1N1C representation.

    1N1C representation is the preferred mode for character recognition and image recognition.


    3.8.4   Training, Retraining and Recognition

    The command, public bool classification(), consists of:
     

      public bool train ()
      Public bool Recognition_classification()


    The command,  public bool distribution (), consists of:
     

      public boolean train ()
      public boolean Recognition_distribution ()


    The same is true for:
     

      public boolean classification1N1C()
      public boolean distribution1N1C ()


    Command "Retrain" is used to retrain the network. Retraining cannot take place until training has been done first. You can have as many retraining as you wish. Every retraining looks for data from the training file. Make sure you offer fresh data to the PolyApplet for each retraining.

    3.8.5   Array Commands

    The Array Commands are:
     

      public boolean train( char a[] )
      public boolean retrain( char a[] )
      public long Recognition_classification1N1C(char[] b)
      public long Recognition_distribution1N1C (char[] b)
      public long polyRecognition_classification1N1C(char[] b)
      public long polyRecognition_distribution1N1C (char[] b)


    You can run PolyApplet without using any files, instead using character arrays.

    Before using the Arrays, use:
     

      void setN( int n)
      int getN( )


    or
     

       void setNeuralNet(int x);
       int getNeuralNet();
       bool getNeuralNetStatus();
    to assign the number of neurons. The format of the Training Array and Recognition Array is the same as the files.

    Example.  Use setN (46) to assign the number of neurons in this example.
    An example of a Training Array is:

    01000 00000 0

           00100
           01100
           00100
           00100
           00100
           00100
           01110


    An example of a Recognition Array is:

    xxxxx xxxxx x

           00100
           01100
           00100
           00100
           00100
           00100
           01110


    3.8.6   Search Commands

    Search Commands compare a new pattern with a set of existing patterns. The neural net is trained with the new pattern, then it will loop through the existing pattern. The commands are:
     

       bool train ( char [] trainArray  );
       bool retrain ( char [] reTrainArray  );
       long match(  char [] matchArray);


    For example, an 1:N match (between a pattern, x[] , and N patterns y[][]) algorithm will be:
     

      B = train (x);
      If (!b)
      Return false;
      For ( I = 1; I < N; I ++ )
      {
       score = match (y[I] );
       if ( max < score )
        {
        max = score;
        matchPosition = I;
        }
      }


    3.9   Test Input File Format

    The Test-Input-File command is:
     

        public boolean testInput()


    If you are not sure of the correctness of the training and recognition files, this command will tell you.

    3.10   Messages

    The Message commands are is stored in:
     

       RichTextBox display.


    3.11   Example Class

    The Class Library, Attrasoft.PolyApplet63.Example provides you with several examples in ABM 2.7 and in PolyNet 4.0. To get this object, declare a PolyApplet x:

    public Attrasoft.PolyApplet63.PolyApplet63 poly
    = new Attrasoft. PolyApplet63.PolyApplet63 ();

    Then poly.example will produce the example object. The public methods are:

    public class Example
    {

      public int
              line2Start = -1,
        line3Start = -1,
        line4Start = -1,
        line5Start = -1;

       public int
        symmtryStart = -1,
        symmtryEnd = -1,
        symmtrXDim = -1,
        symmtryYDim = -1,
        symmetryIndex = 0;

       public String trainFileName = "example1a.txt";
       public String recognitionFileName ="example1b.txt";
       public String outputFileName = "example1c.txt";

      public void ocr5x7 ()
      public void ocr8x8 ()
      public void ocr19x19 ()
      public void ocr32x32 ()

      public void shifter1 ()
      public void shifter2 ()
      public void shifter3 ()
      public void shifter4 ()

      public void scaling2D ()
      public void rotation2D ()
      public void rotationScaling2D ()

      public void nursery ()
      public void cancer ()

      public void math1 ()
      public void math2 ()

    }

    Please refer to User's Guide of ABM 2.7 and PolyNet 4.0 for these examples.

    3.12  Common Errors

    Common Errors are:
     

    • The number of neurons is out of range. To correct the problem, make the number larger than 6 and less than 10001.
    • The training and recognition files are not linked.
    • The formats of the training and recognition files are not right. To check, click "Data/Test".
    Return