Does LVQ require labels?

Yes. Labels determine whether a prototype is moved toward or away from a training example in the basic method.

Can one class have several prototypes?

Yes. This can represent multiple regions belonging to the same class.

Is LVQ the same as a self-organizing map?

No. They are related historically, but LVQ is supervised classification and a standard self-organizing map has a different learning objective.

AI Glossary / AI and machine learning / Intermediate

Learning vector quantization

Definition

Learning vector quantization, or LVQ, is a family of supervised classification methods that represents classes with labeled prototype vectors. Training adjusts the prototypes so that nearby examples are more likely to receive the correct class label.

What it means

A prototype is a representative point in the feature space. A class can have several prototypes, allowing it to occupy different regions. To classify a new example, a basic LVQ system finds the nearest prototype and returns its label.

The word “quantization” reflects the use of a finite set of representative vectors, but LVQ is primarily a supervised classification approach. It should not be confused with every form of unsupervised vector quantization or with lattice vector quantization, which can share the abbreviation LVQ in other contexts.

Prototypes offer a compact representation that can sometimes be inspected. However, a prototype is a learned numerical vector and may not correspond to a real observed item. Its interpretability depends on the features and the distance measure.

How it works

Training begins with labeled prototypes placed in the feature space. In the simple LVQ1 rule, the closest prototype to a labeled training example is selected. If its label is correct, it moves toward the example. If its label is wrong, it moves away.

The amount of movement depends on a learning rate. Repeated updates reshape the classification regions. Variants change which prototypes are updated, define an explicit objective or learn feature relevance and distance metrics.

Feature scaling and initialization matter because nearest-prototype decisions depend on geometry. The number of prototypes controls representational capacity and storage. Too few may miss important structure, while too many can fit noise. Training settings should be chosen with validation data, and performance should be checked on independent examples, including minority classes and changing conditions.

Three practical examples

1. A quality-control classifier represents several product categories with a small set of labeled measurement prototypes.

2. A teaching exercise visualizes how prototypes move toward correctly labeled examples and away from incorrectly labeled ones.

3. A pattern-recognition team compares an LVQ model with a nearest-neighbor baseline to examine whether a compact learned representation retains useful classification performance.

Think of it this way

Think of placing labeled signposts on a map and assigning each location to its nearest signpost. Training moves the signposts to improve the assignments. The limit is that the map is a feature space whose distances may not match human notions of similarity, and a signpost need not represent a real item.

Worked example

Suppose a one-dimensional prototype is at 4 and a training example is at 6. With learning rate 0.2, a correct-label LVQ1 update moves the prototype toward the example: 4 + 0.2 × (6 - 4) = 4.4.

If the nearest prototype had the wrong label, the corresponding simple update would move it away: 4 - 0.2 × (6 - 4) = 3.6.

These are illustrations of the basic update, not every LVQ variant. They show how label information changes the direction of movement. Repeated updates must be evaluated as a complete learning process; one movement does not establish that the final boundary will be good.

Illustrative case study

A fictional packaging plant uses LVQ to classify measured shapes. The first model performs poorly because one feature is measured in thousands while others range between zero and one, so distances are dominated by that feature.

The team defines a justified scaling procedure using training data and compares several prototype counts. It also inspects examples near class boundaries rather than assuming the learned prototypes are perfect representatives of every package.

The case illustrates that prototype methods depend on feature geometry. Their compactness makes some behavior easier to examine, but it does not remove the need for preprocessing, evaluation and attention to difficult examples.

Common misconceptions and mistakes

LVQ is ordinary unsupervised clustering. Class labels guide prototype updates.
Every prototype must be an actual training example. Learned prototypes can occupy positions not present in the data.
More prototypes always improve generalization. Additional capacity can fit noise and complicate the model.

Business use

LVQ can be useful where a compact prototype-based classifier is appropriate and the feature space supports meaningful distance comparisons. It can also serve as an accessible way to explain supervised representation learning.

Compare it with simpler classifiers and nearest-neighbor methods using the same preprocessing and data splits. Check whether prototypes are understandable in the chosen feature representation. Measure performance separately for important classes and monitor whether operating changes move new examples away from the learned regions. A small model is easier to store, but still needs lifecycle management.

Check your understanding

Why does the basic LVQ1 rule move an incorrectly labeled nearest prototype away from the example?

Answer: It aims to reduce that prototype's influence in a region associated with another class, improving the future classification boundary.

Related terms

Vector quantization
Nearest neighbor
Supervised learning
Metric Learning
prototype learning
self-organising map
feature scaling

Learn next

Read nearest-neighbor classification and prototype learning. Draw a two-class example and follow several LVQ1 updates, noting how initial positions and scaling affect the result.

Nearest neighbor

Sources

Kohonen, Hynninen, Kangas, Laaksonen and Torkkola, LVQ_PAK: The Learning Vector Quantization Program Package (1996), author institution record: https://research.aalto.fi/fi/publications/lvqpak-the-learning-vector-quantization-program-package. Researchers' review of LVQ classifiers: https://arxiv.org/abs/1509.07093. The numerical update and packaging-plant scenario are invented.

Previous: Learning to rank Next: Least absolute deviation regression