
lrfclass(1)                  Khoros                   lrfclass(1)

PROGRAM
     lrfclass - Classify an image using the Localized Receptive
     Field classifier.

SYNTAX
     lrfclass

     -i1            input image

     -i2            cluster center image

     -i3            cluster variance image

     -i4            weight image

     -o             classified image

     [-b]           Border Width

     [-V]           Gives the version for lrfclass

     [-U]           Gives the usage for lrfclass

     [-P]           Prompts for command line options

     [-A [file1]]   Creates the answer file called lrfclass.ans
                    or file1

     [-a [file1]]   Uses lrfclass.ans or file1 as the answer file

DESCRIPTION
     lrfclass classifies an image using the Localized Receptive
     Field classifier (LRF).  The Localized Receptive Field (LRF)
     is based on a single layer of self-organizing, "localized
     receptive field" units, followed by a single layer percep-
     tron.  The single layer of perceptron units use the LMS or
     Adaline learning rule to adjust the weights.  The weights
     are adjusted or "trained" using the companion program,
     "lrftrain".  After training the weights, using the
     "lrftrain" program, a number of similar images may be
     quickly classified with this program based on the training
     data set.

     LRF network theory

     The basic network model of the LRF consists of a two layer
     topology.  The first layer of "receptive field" nodes are
     trained using a clustering algorithm, such as K-means, or
     some other algorithm which can determine the receptive field
     centers.  Each node in the first layer computes a receptive
     field response function, which should approach zero as the
     distance from the center of the receptive field is
     increased.  The second layer of the LRF model sums the
     weighted outputs of the first layer, which produces the out-
     put or response of the network.  A supervised LMS rule is
     used to train the weights of the second layer nodes.

     The response function of the LRF network is formulated as
     follows:

                  f(x) = SUM(Ti * Ri(x))

     where,

           Ri(x) = Q( ||x - xi|| / Wi )

           x  -  is a real valued vector in the input space,
           Ri -  is the ith receptive field response function,
           Q  -  is a radially symmetric functio with a single
                 maximum at the origin, decreasing to zero at
                 large radii,
           xi -  is the center of the ith receptive field,
           Wi -  is the width of the ith receptive field,
           Ti -  is the weight associated with each receptive
     field.

     The receptive field response functions ( Ri(x) ), should be
     formulated such that they decrease rapidly with increasing
     radii.  This ensures that the response functions provide
     highly localized representations of the input space.  The
     response function used in this algorithm is modeled after
     the gaussian, and uses the trace of the covariance matrix to
     set the widths of the receptive field centers.

     Prior to using this algorithm, it is necessary to "train"
     the weights for the output layer by running the companion
     program, "lrftrain", on a previously clustered image.  Thus
     the inputs to this program are the original input image (-
     i1), the cluster center image (-i2), the cluster variance
     image (-i3), and the weight image (-i4).  The original input
     image contains all of the features used in the original
     clustering (ie. vkmeans).  The cluster center image (-i2)
     contains the locations of the cluster centers in the input
     feature space, which fixes the centers of the localized
     receptive fields. The cluster variance image (-i3) contains
     the variances associated with each cluster center.  This
     establishes the widths of the localized receptive field
     gaussians.  The weight image (-i4) contains all of the
     weights for each node in the output layer.

     The number of receptive field response nodes in the first
     layer of the LRF is determined by the number of cluster
     centers in the "cluster center" image.  The number of output
     classes, and hence the number of output nodes in the second
     (ie. last) layer, is determined by the number of desired
     classes that was specified in the "supervised" classifica-
     tion phase of the clustering.  This information is contained
     in the last band of the cluster center image.  The number of
     weights in the network is determined by the number of recep-
     tive field response nodes and the number of output nodes.
     That is,

       #Wts = (#rf_response_nodes * #output_nodes) +
     #output_nodes

     The resulting output image is classified with the desired
     number of classes specified in the last band of the "cluster
     center" (-i2) image.  The number of desired classes
     corresponds to the number of output nodes in the last layer
     of the LRF network.  This classified image is of data
     storage type INTEGER.

     Input Options

     -b      is an integer that specifies the border width, in
             pixels, encompassing the desired region of the image
             to be classified.  This region is ignored during the
             classification process.

     This routine was written with the help of and ideas from Dr.
     Don Hush, University of New Mexico, Dept. of EECE.

REQUIRED ARGUMENTS
     -i1    type: infile
            desc: input image

     -i2    type: infile
            desc: cluster center image

     -i3    type: infile
            desc: cluster variance image

     -i4    type: infile
            desc: weight image

     -o     type: outfile
            desc: classified image

OPTIONAL ARGUMENTS
     -b     type: integer
            desc: Border Width
            default: 0
            bounds: 0 < [-b] < 100

EXAMPLES
     lrfclass -i1 feature_image.xv -i2 cluster_centers -i3 vari-
     ances -i4 weight_image -o classified_image -b 4

     This example uses feature_image.xv as the input feature
     image, and the three other images from the companion program
     "lrftrain". These include the cluster_centers image, the
     variances image, and the weight_image. The resulting classi-
     fied image is stored as "classified_image".  A border width
     of 4 pixels is specified, which will cause the outermost
     four pixels of the image to be ignored.

SEE ALSO
     intro(1), verror(3), vgparms(3), vutils(3), llrfclass(3)
     lrftrain(1)

RESTRICTIONS
     All input images MUST be of data storage type FLOAT.  The
     resulting classified image (-o) is of data storage type
     INTEGER.

COPYRIGHT
     Copyright 1991, University of New Mexico.  All rights
     reserved.

Khoros                    Release: 1.0                          1

