create_class_lut_mlp — Create a look-up table using a multi-layer perceptron to classify byte
images.
create_class_lut_mlp( : : MLPHandle, GenParamName, GenParamValue : ClassLUTHandle)
create_class_lut_mlp generates a look-up table (LUT)
ClassLUTHandle using the data of a trained multi-layer perceptron
(MLP) MLPHandle to classify multi-channel byte images. By using
this MLP-based LUT classifier the operator classify_image_class_mlp
of the subsequent classification can be replaced by the operator
classify_image_class_lut. The classification gets a major speed-up,
because the estimation of the class in every image point is no longer
necessary since every possible response of the MLP is stored in the LUT.
For the generation of the LUT, the parameters NumInput,
Preprocessing, and NumComponents defined in the earlier
called operator create_class_mlp are important.
In NumInput, the number of image channels the images must have to be
classified is defined. By using the Preprocessing
(see create_class_mlp) the number of image channels can be
transformed to NumComponents. NumComponents defines
the length of the feature vector, which the classifier
classify_class_mlp handles internally. Because of performance and
disk space, the LUT is restricted to be maximal 3-dimensional. Since
it replaces the operator classify_class_mlp,
NumComponents <= 3 must hold.
If there is no preprocessing that reduces the number of image channels
(NumInput = NumComponents), all possible pixel values,
which can occur in a byte image, are classified with
classify_class_mlp. The returned classes are stored in the LUT.
If there is a preprocessing that reduces the number of image channels
(NumInput > NumComponents), the preprocessing parameters
of the MLP are stored in a separate structure of the LUT. To create the LUT,
all transformed pixel values are classified with classify_class_mlp.
The returned classes are stored in the LUT. Because of the discretization
of the LUT, the accuracy of the LUT classifier could become lower than the
accuracy of classify_image_class_mlp.
With 'bit_depth' and 'class_selection' the accuracy of
the classification, the required storage, and the runtime needed to create
the LUT can be controlled.
The following parameters of the MLP-based LUT classifier can be set with
GenParamName and GenParamValue:
Number of bits used from the pixels. It controls the storage requirement
of the LUT classifier and is bounded by the bit depth of the image
('bit_depth' <= 8). If the bit depth of the
LUT is smaller ('bit_depth' < 8), the classes
of multiple pixel combinations will be mapped to the same LUT entry,
which can result in a lower accuracy for the classification. One of these
clusters contains
pixel combinations,
where NumComponents denotes the dimension of the LUT, which is
specified in create_class_mlp. For example,
for 'bit_depth' = 7,
NumComponents = 3, the classes of 8 pixel
combinations are mapped in the same LUT entry. The LUT requires at most
bytes of storage.
For example, for NumComponents = 3,
'bit_depth' = 8 and NumOutput < 16
(specified in create_class_mlp), the LUT requires 8 MB of storage
with internal storage optimization. If NumOutput = 1,
the LUT requires only 2 MB of storage by using the full bit depth of the
LUT. The runtime for the classification in classify_image_class_lut
becomes minimal if the LUT fits into the cache.
The default value is 8,
typical values are [6,7,8].
Restrictions: 'bit_depth' >= 1,
'bit_depth' <= 8.
Method for the class selection for the LUT. Can be modified to control
the accuracy and the runtime needed to create the LUT classifier.
The value in 'class_selection' is ignored if the bit depth of
the LUT is maximal, thus 'bit_depth' = 8 holds.
If the bit depth of the LUT is smaller
('bit_depth' < 8), the classes of multiple pixel
combinations will be mapped to the same LUT entry. One of these clusters
contains
pixel combinations,
where NumComponents denotes the dimension of the LUT, which is
specified in create_class_mlp. By choosing
'class_selection' = 'best', the class that
appears most often in the cluster is stored in the LUT.
For 'class_selection' = 'fast', only one pixel of the
cluster, i.e., the pixel with the smallest value (component-wise), is
classified. The returned class is stored in the LUT. In this case, the
accuracy of the subsequent classification could become lower. On the other
hand, the runtime needed to create the LUT can be reduced, which is
proportional to the maximal needed storage of the LUT, which is defined
with
.
The default value is 'fast',
possible values are ['fast', 'best'].
Threshold for the rejection of uncertain classified points of the MLP.
The parameter represents a threshold on the probability measure
returned by the classification (see classify_class_mlp and
evaluate_class_mlp). All pixels having a probability below
'rejection_threshold' are not assigned to any class.
The default value is 0.5.
Restriction: 'rejection_threshold' >= 0,
'rejection_threshold' <= 1.
This operator returns a handle. Note that the state of an instance of this handle type may be changed by specific operators even though the handle is used as an input parameter by those operators.
MLPHandle (input_control) class_mlp → (handle)
MLP handle.
GenParamName (input_control) attribute.name-array → (string)
Names of the generic parameters that can be adjusted for the LUT classifier creation.
Default value: []
Suggested values: 'bit_depth', 'class_selection', 'rejection_threshold'
GenParamValue (input_control) attribute.value-array → (string / integer / real)
Values of the generic parameters that can be adjusted for the LUT classifier creation.
Default value: []
Suggested values: 8, 7, 6, 'fast', 'best'
ClassLUTHandle (output_control) class_lut → (handle)
Handle of the LUT classifier.
If the parameters are valid, the operator create_class_lut_mlp
returns the value TRUE. If necessary an exception is raised.
train_class_mlp,
read_class_mlp
create_class_lut_gmm,
create_class_lut_knn,
create_class_lut_svm
classify_image_class_lut,
clear_class_lut
Foundation