Multinomial Logistic Regression

Introduction

Multinomial logistic regression is the workhorse model data scientists reach for when an outcome has three or more unordered categories. It extends ordinary binary logistic regression so one model can separate many classes at once. The method powers everyday decisions, from sorting support tickets to predicting which product a shopper will choose. Despite the rise of deep learning, neural networks beat logistic models in only about 60 percent of clinical tasks, with a mean AUC gain near 0.03 (healthcare modeling research). That slim margin keeps multinomial logistic regression relevant as a fast, interpretable baseline against far heavier methods. This guide walks through the softmax math, the Python code, and the interpretation rules that turn raw coefficients into clear answers. By the end, you will know when to trust the model and when a richer method earns its place.

Quick Answers on Multinomial Logistic Regression

What is multinomial logistic regression?

Multinomial logistic regression is a classification model that predicts one outcome from three or more unordered categories. It uses the softmax function to turn feature scores into class probabilities that sum to one.

How is multinomial logistic regression different from binary logistic regression?

Binary logistic regression separates two classes with one equation. Multinomial logistic regression fits a separate set of coefficients for each class against a reference, handling many categories in a single model.

When should you use multinomial logistic regression?

Use multinomial logistic regression when classes are unordered, predictors relate linearly to the log odds, and you need fast, interpretable probabilities rather than a complex black-box model.

Key Takeaways

• Multinomial logistic regression predicts one of three or more unordered classes using the softmax function to produce calibrated probabilities.
• The model reports results as odds ratios against a reference category, which makes each predictor effect easy to explain.
• It remains a fast, interpretable baseline because neural networks lift clinical AUC by only about 0.03 on average.
• Solver and regularization choices in scikit-learn control training speed, accuracy, and the risk of overfitting.

What Is Multinomial Logistic Regression?

Multinomial logistic regression is a supervised model for unordered outcomes. It predicts three or more classes from weighted input features. The softmax function converts those scores into probabilities summing to one. Each class is measured against one chosen reference category. The result is calibrated, interpretable probabilities for every possible outcome.

How Multinomial Logistic Regression Works

To see how the multinomial model works, picture a model that scores every possible class for each input. The algorithm assigns one set of weights to each category, then multiplies those weights by the input features. Each class receives its own linear score, and the highest score points toward the most likely category. These raw scores, called logits, can be any real number, whether positive or negative. The model converts them into probabilities so the results stay easy to compare. This structure builds directly on ordinary linear regression in machine learning, which produces one continuous score from weighted features. The jump to many classes simply repeats that scoring step once per category.

Training the model means finding weights that make the predicted probabilities match the observed labels. The learning process compares each prediction against the true class using a loss function. The classifier relies on cross-entropy loss, which punishes confident but wrong predictions heavily. Because no formula solves the weights directly, the model uses iterative optimization like gradient descent. Each pass nudges the weights to lower the average loss across the training set. Over many passes, the scores sharpen so correct classes earn higher probabilities. This optimization mirrors how most supervised learning models learn from labeled examples.

Once trained, the model predicts by scoring a new input and selecting the class with the largest probability. The full probability vector matters as much as the single winning label in many applications. A fraud system, for example, may act only when the top probability clears a strict threshold. The same scores feed dashboards that rank outcomes by confidence for human reviewers. This transparency is one reason analysts still favor the method over opaque alternatives. Clear probabilities make the model easy to audit, explain, and defend to stakeholders.

The Softmax Function at the Heart of the Model

Building on those raw scores, the softmax function is the engine that turns logits into probabilities. It takes the score for each class, exponentiates it, then divides by the sum of all exponentiated scores. The softmax function guarantees every probability lands between zero and one and that the full set sums to one. This normalization lets the model express genuine uncertainty across competing classes. A near-tie between two categories produces two moderate probabilities rather than a forced choice. The exponential step also magnifies large scores, so a clear winner earns a sharp, confident probability. Analysts often compare the softmax function to the sigmoid function, which handles the simpler two-class case.

The exponential weighting carries a practical consequence worth remembering during modeling. Because softmax is sensitive to the scale of inputs, unscaled features can dominate the scores unfairly. Standardizing predictors before training keeps the probabilities balanced and stable. The function is also shift-invariant, meaning adding a constant to every score leaves the result unchanged. Libraries exploit this property to avoid numerical overflow when exponentiating large values. Understanding softmax demystifies why the model produces calibrated, comparable outputs for every class.

From Binary to Multinomial: Generalizing Logistic Regression

Shifting focus to the bigger picture, softmax regression generalizes the familiar binary model in a clean way. Binary logistic regression estimates one equation that separates a positive class from a negative class. This model instead fits a separate coefficient set for each class measured against a single reference category. The reference category acts as the baseline that every other category is compared with. If an outcome has five classes, the model learns four contrasts plus the implied baseline. This design keeps the probabilities coherent while still scaling to many categories. The approach treats classes jointly rather than training many isolated yes-or-no models.

This joint treatment separates true multinomial models from the one-versus-rest shortcut. One-versus-rest trains a distinct binary classifier for each class against all others combined. That trick works, yet its probabilities need rescaling because they do not naturally sum to one. The multinomial approach avoids the patch by optimizing every class together with shared normalization. Research on text datasets like 20newsgroups shows multinomial training is faster and more accurate at scale. The difference grows when classes overlap and clean separation is impossible.

It also helps to distinguish multinomial outcomes from ordinal ones, which carry a natural order. Customer ratings from poor to excellent are ordinal because the categories rank in sequence. Multinomial models ignore any ordering and treat each category as a distinct, unranked option. Choosing the wrong variant wastes information or invents structure that does not exist. When order genuinely matters, an ordinal model usually fits the data more efficiently. When categories are simply different, like transport modes or product types, the multinomial form is correct.

The generalization connects the model to a wider family of common machine learning algorithms. Decision-based methods such as classification and regression trees split the feature space differently but solve the same task. Margin-based methods like support vector machines draw boundaries without producing probabilities by default. The multinomial model stands out by combining linear simplicity with honest, calibrated probability estimates. That blend explains its staying power across statistics, economics, and machine learning. Knowing where it sits in the family helps you pick the right tool for each problem.

Interpreting Coefficients and Odds Ratios

Turning to interpretation, the real payoff of the method is its readable coefficients. Each coefficient describes how a one-unit change in a predictor shifts the log odds of a class versus the reference. Exponentiating a coefficient converts it into an odds ratio, the most intuitive way to report the effect. An odds ratio above one means the comparison class becomes more likely as the predictor rises. An odds ratio below one means that class becomes less likely relative to the baseline. This framing lets analysts speak in plain terms about risk and preference. The reference category is the anchor for every one of these comparisons.

A concrete example makes the odds ratio tangible and easy to communicate. In a transport study, the odds of driving rather than walking rose 5.46 times for each extra kilometer of distance (Statistics By Jim). For the same model, the odds of taking a bus instead of walking rose 1.92 times per kilometer. Income worked the other way, cutting the odds of the bus by 13 percent for every extra thousand dollars. Each number ties directly to one predictor and one class contrast. Reporting results this way turns abstract weights into decisions a manager can act on.

Careful interpretation also means respecting the limits of a single coefficient. Odds ratios describe association, not proven cause, so confounding variables can distort the story. Confidence intervals reveal how precise each estimate is and whether it could simply be noise. Changing the reference category rescales every contrast, so the baseline choice should be deliberate. Output from tools like SPSS or scikit-learn reports these values alongside significance tests. Reading them together keeps conclusions honest and defensible under scrutiny.

The Assumptions That Keep the Model Valid

Stepping back from interpretation, this approach rests on assumptions that protect its validity. The most distinctive is the independence of irrelevant alternatives, often shortened to IIA. The IIA assumption holds that adding or removing an unrelated option should not change the odds between two existing classes. A classic illustration is that offering a bicycle should not shift the relative odds of choosing a car over a bus. The model also assumes little multicollinearity, so predictors should not be near-duplicates of one another. A linear relationship between predictors and the log odds rounds out the core requirements.

Sample size is the quiet assumption that derails many real projects. Each category needs enough observations to estimate stable coefficients, especially with many predictors. Rare classes produce wild, untrustworthy estimates that swing with a handful of cases. Analysts often check IIA with a Hausman test and inspect variance inflation factors for collinearity. When assumptions fail, remedies include merging sparse categories, dropping redundant features, or switching to a nested model. Testing these conditions before trusting the output separates rigorous work from wishful thinking.

Choosing Solvers, Penalties, and Regularization

Building on those assumptions, practical fitting hinges on the solver and regularization you select. A solver is the optimization routine that searches for the coefficients minimizing cross-entropy loss. In scikit-learn, the lbfgs and newton-cg solvers handle multinomial problems well on small and medium datasets. The saga solver scales to large datasets and supports more penalty types (scikit-learn documentation). Each solver trades speed, memory, and flexibility, so the data size guides the choice. Matching the solver to the problem prevents slow convergence and wasted compute. The right pairing often shortens training from minutes to seconds.

Regularization is the second lever that controls how the model balances fit and simplicity. L2 regularization shrinks coefficients toward zero, taming large weights and reducing overfitting. L1 regularization can push weights exactly to zero, performing automatic feature selection. Elasticnet blends both penalties and suits datasets with many correlated predictors. The strength parameter, often called C in scikit-learn, sets how aggressive the penalty is. A smaller C means stronger regularization and a simpler, steadier model.

Choosing the penalty strength is where careful validation pays off. Tuning C with cross-validation to reduce overfitting guards against both overfitting and underfitting. A model that memorizes the training set will stumble badly on fresh examples, a classic case of overfitting and underfitting. Grid search or randomized search over a range of C values reveals the sweet spot. Pairing this with stratified folds keeps every class represented in each validation split. The result is a model that generalizes rather than merely echoing the training labels.

Feature preparation quietly shapes how well any solver performs. Standardizing numeric predictors keeps the softmax scores balanced and speeds convergence. Encoding categorical predictors with one-hot vectors lets the model weigh each level independently. Removing near-duplicate features respects the low-multicollinearity assumption discussed earlier. Python remains the dominant environment for this work, and several other programming languages support the same workflow. Thoughtful preparation often improves accuracy more than swapping one solver for another.

Evaluating and Validating Your Multinomial Logit Model

Building on those choices, evaluating a multinomial logit model demands more than a single accuracy score. Accuracy alone hides trouble when classes are imbalanced and one category dominates the data. A confusion matrix reveals exactly which classes the model confuses, turning a vague score into actionable insight. Precision, recall, and the F1 score expose performance for each class separately. Macro and weighted averages then summarize those per-class numbers in one comparable figure. Looking at every class keeps a strong overall score from masking a weak minority class. This per-class view is essential whenever every category carries real consequences.

Probability quality matters as much as the hard label the model picks. A well-calibrated model assigns an 80 percent probability to events that occur about 80 percent of the time. Calibration plots and the Brier score measure how honest those probabilities are. The multinomial form tends to produce better-calibrated outputs than stitched-together binary models. Log loss, the same cross-entropy used in training, doubles as a strict evaluation metric. Tracking it on held-out data flags overconfident predictions before they reach production.

Validation strategy decides whether your reported numbers will survive deployment. Stratified k-fold cross-validation keeps each class proportionally represented across every fold. A separate holdout test set, untouched during tuning, gives the final unbiased estimate. Time-based splits matter when data drifts, so future records never leak into training. Comparing the model against a simple majority-class baseline confirms it adds genuine value. Disciplined validation is the difference between a demo that dazzles and a model that endures.

Common Pitfalls and Risks With Multiple Classes

Despite the clarity of the method, the multinomial model carries pitfalls that punish careless modeling. Class imbalance is the most common trap, where rare categories get ignored in favor of frequent ones. An imbalanced dataset can produce a model that looks accurate yet never predicts the minority class at all. Resampling, class weights, and threshold tuning help restore balance to the predictions. Complete separation is another hazard, where a predictor perfectly splits a class and coefficients explode. Regularization or combining sparse categories usually tames that instability.

Misreading the output causes errors that no algorithm can catch for you. Analysts sometimes interpret odds ratios as probabilities, which overstates the size of an effect. Others forget that every contrast depends on the reference category they happened to choose. Ignoring the IIA assumption can quietly bias choices in market and transport studies. Feeding correlated predictors inflates standard errors and destabilizes the coefficients. Guarding against these mistakes protects both the model and the decisions built on it.

Ethics, Fairness, and Accountability in Multi-Class Models

Beyond technical accuracy, multi-class models increasingly steer decisions that affect real people. A model that sorts loan applicants or patients into categories can encode historical bias from its training data. Fairness fails silently when a model assigns worse categories to protected groups despite equal qualifications. Interpretable coefficients give multinomial logit an advantage here, because every effect is open to inspection. Auditors can read the odds ratios and question why a feature pushes one group toward a harmful class. That transparency supports accountability that opaque deep models struggle to match. Clear reasoning is a prerequisite for trust in high-stakes settings.

Bias often enters through the data long before any model is fit. Skewed sampling, proxy variables, and mislabeled categories all distort the learned coefficients. The well-documented dangers of AI bias and discrimination show how small data flaws scale into systemic harm. Removing a sensitive feature rarely solves the problem, since correlated proxies carry the same signal. Fairness metrics like equal opportunity and demographic parity quantify disparate treatment across groups. Measuring these gaps is the first step toward correcting them responsibly.

Accountability means documenting choices so others can challenge them later. A model card records the data, the reference category, the metrics, and the known limitations. Human review should stay in the loop wherever a misclassification could cause serious harm. Regulators increasingly expect explanations for automated decisions in finance and healthcare. The readability of softmax regression makes it easier to meet those expectations than many alternatives. Responsible deployment treats fairness as an ongoing audit, not a one-time checkbox.

The Future of Multinomial Logistic Regression in a Deep Learning Era

Looking ahead, the classifier is unlikely to fade despite the surge in deep learning. Its convex loss surface guarantees a single global optimum, a property neural networks sacrifice for flexibility. That mathematical guarantee makes the model a dependable baseline that complex systems must justify beating. Studies still find that neural networks improve clinical performance only marginally over logistic models. When data is limited or interpretability is mandatory, the simpler model frequently wins outright. The future looks less like replacement and more like a thoughtful division of labor.

The technique is also evolving rather than standing still. Practitioners now embed the model as the final layer of larger neural architectures. In that role, softmax classification turns rich learned features into clean class probabilities. Regularized and sparse variants keep the method viable for high-dimensional text and genomics data. Tooling continues to mature, with scikit-learn defaulting modern solvers to the multinomial formulation. These refinements extend the model’s reach without abandoning its interpretable core.

Calibrated probability will likely define the model’s lasting value. As organizations demand trustworthy uncertainty estimates, well-calibrated classifiers gain importance over raw accuracy. The basics of neural networks still rely on softmax, linking this classic method to cutting-edge systems. Hybrid pipelines pair deep feature extraction with transparent logistic decision layers for auditability. Education and regulation both reward models that humans can actually understand. For these reasons, the method will remain a staple of the practical toolkit.

How to Implement Multinomial Logistic Regression in Python

In practice, this walkthrough builds a working the multinomial model model in Python. Each part uses scikit-learn, the most popular library for classic machine learning. Follow the parts in order, moving from raw data to interpretable odds ratios. The example uses a small public dataset so you can reproduce every result quickly. The same pattern scales to larger, messier datasets with minimal changes. Read the code comments to understand what each line contributes.

The first part installs the libraries and imports the classes you need. The scikit-learn package supplies the model, while pandas and numpy handle the data. Installing everything in a virtual environment keeps project dependencies isolated and reproducible. Import only the specific classes you need rather than whole modules. Pro tip: pin library versions in a requirements file so your results stay reproducible months later. A tidy setup prevents version conflicts that quietly change model behavior.

pip install scikit-learn pandas numpy

import pandas as pd
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report

The second part loads a dataset whose target has three or more unordered classes. The classic Iris dataset works well because it has three flower species. Inspecting the features and the class counts reveals the shape of the problem. Checking the balance of each class early warns you about imbalance before training. A quick summary of the predictors confirms their scales differ and need standardizing. Understanding the data prevents surprises once the model starts learning.

from sklearn.datasets import load_iris

data = load_iris(as_frame=True)
X = data.data
y = data.target
print(X.head())
print(y.value_counts())

The third part splits the data into training and testing sets before touching the model. A stratified split keeps each class proportionally represented in both sets. Scaling the features matters because softmax is sensitive to predictor magnitude. Fit the scaler on the training data only, then apply it to the test data. This discipline prevents information from the test set leaking into training. Proper splitting and scaling set the stage for trustworthy evaluation.

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

The fourth part creates the classifier with settings tuned for a multinomial problem. The lbfgs solver fits the model quickly on this small, clean dataset. The C parameter sets regularization strength, and one is a sensible starting point. Raising max_iter gives the optimizer room to converge fully. Recent scikit-learn versions apply the multinomial formulation automatically. Choosing these options deliberately keeps the model stable and reproducible.

model = LogisticRegression(
    solver="lbfgs",
    C=1.0,
    max_iter=1000)

The fifth part fits the model on the training data, then judges it on the unseen test set. The classification report breaks down precision, recall, and F1 for each class. Cross-validation on the training data confirms the score is not a lucky split. Comparing per-class metrics exposes any category the model handles poorly. A strong macro average signals balanced performance across every class. Evaluating this thoroughly earns confidence before any deployment.

model.fit(X_train, y_train)
preds = model.predict(X_test)
print(classification_report(y_test, preds))

scores = cross_val_score(model, X_train, y_train, cv=5)
print("CV accuracy:", scores.mean())

The final part translates the learned weights into the odds ratios that drive interpretation. Exponentiating each coefficient converts log odds into a multiplicative effect. An odds ratio above one means the feature raises the odds of that class. An odds ratio below one means the feature lowers them relative to the baseline. Pairing each ratio with its feature name makes the output readable for stakeholders. This final step turns a trained model into clear, defensible business insight.

odds_ratios = np.exp(model.coef_)
for class_index, row in enumerate(odds_ratios):
    print("Class", class_index, dict(zip(X.columns, row.round(3))))

Key Insights That Define Multinomial Logistic Regression Today

• Neural networks outperform logistic regression in only about 60 percent of clinical tasks, with a mean AUC improvement of just 0.03 (healthcare modeling research).
• In a commuter study, the odds of driving rather than walking rose 5.46 times for each additional kilometer of distance (Statistics By Jim).
• Every extra one thousand dollars of income cut the odds of taking a bus instead of walking by 13 percent in the same model (Statistics By Jim).
• The softmax function maps any set of class scores to probabilities that always sum to exactly one (Stanford softmax tutorial).
• On the 20newsgroups corpus of twenty classes, multinomial training runs faster and scores more accurately than one-versus-rest (scikit-learn benchmark).
• The scikit-learn saga solver supports L1, L2, and elasticnet penalties for large multinomial problems with many features (scikit-learn documentation).
• UCLA’s classic teaching example fits a three-category program-choice model on 200 high-school students using writing score and status (UCLA OARC).
• A common rule of thumb requires at least 10 outcome events per predictor for stable multinomial estimates (ScienceDirect overview).

Taken together, these numbers explain why multinomial logit endures in serious practice. The model trades a sliver of accuracy for transparency, calibration, and speed that complex systems rarely match. Its odds ratios translate directly into decisions about transport, health, and education. The same softmax mechanism that powers it now sits inside many modern neural networks. Its main risks, from IIA violations to thin per-class samples, are well understood and manageable. Used with care, it remains one of the most dependable classifiers available.

Multinomial Logistic Regression Versus Other Classification Models

Beyond the model itself, comparing it against its peers clarifies when each tool fits best. The technique wins on interpretability and calibrated probabilities, not on raw flexibility. Binary logistic regression shares its transparency but handles only two classes. Decision trees capture non-linear patterns yet often produce poorly calibrated scores. Neural networks model complex boundaries at the cost of speed and explainability. The table below contrasts these methods across the dimensions that matter most in practice. Reading it helps you match the method to your data and constraints.

Dimension	Multinomial Logistic	Binary Logistic	Decision Trees	Neural Networks
Outcome type	Three or more unordered classes	Two classes only	Any number of classes	Any number of classes
Probability output	Calibrated, sums to one	Calibrated for two classes	Approximate, often poorly calibrated	Calibrated via softmax layer
Interpretability	High, via odds ratios	High, via odds ratios	Medium, via split rules	Low, mostly opaque
Training speed	Fast	Fast	Fast	Slow, compute heavy
Handles non-linearity	Limited without engineering	Limited without engineering	Strong	Strong
Data size needed	Modest	Modest	Modest	Large
Main assumption or risk	IIA and linear log odds	Linear log odds	Overfitting	Overfitting and opacity
Typical use	Mode choice, triage tiers	Yes or no risk scoring	Rule-based segmentation	Vision and language tasks

Multinomial Logistic Regression Examples Across Industries

Commuter Transport Mode Choice

In practice, transport planners deployed a the classifier model to predict how commuters choose between walking, driving, and taking the bus. Clear odds ratios let the team turn raw survey data into concrete route planning decisions. The team trained the model on survey data using distance and income as predictors against walking as the reference. The fitted model showed the odds of driving rather than walking rose 5.46 times for each additional kilometer (Statistics By Jim). Each extra thousand dollars of income cut the odds of choosing the bus by 13 percent. The clear odds ratios let planners forecast demand and target new routes with confidence. The main limitation is the IIA assumption, since adding a new mode like cycling could distort the existing contrasts. Analysts therefore validated the model before extending it to additional travel options.

Large-Scale Newsgroup Text Classification

Engineers ran sparse the model on the 20newsgroups corpus to sort posts into twenty topic categories. They trained the model with the saga solver and an L1 penalty to drive most coefficients to zero. The sparse model classified the majority of held-out posts correctly while keeping only a small fraction of features active (scikit-learn benchmark). Training the multinomial form proved faster and delivered a measurable accuracy increase over the one-versus-rest alternative. The pruned feature set also made the model lighter to deploy and easier to inspect. Its limitation is that a bag-of-words representation ignores word order and context entirely. Teams that needed deeper language understanding later layered the classifier on top of richer embeddings.

Iris Species Identification

Educators rolled out the Iris dataset to teach the method on three flower species. The workflow trained a scaled model on four petal and sepal measurements with the lbfgs solver. On a stratified holdout split, the model classified roughly 97 percent of test flowers correctly across all three classes (scikit-learn documentation). The balanced classes and clean measurements made the probabilities sharp and reliable. The example demonstrates the full pipeline from scaling to interpretation in a few lines of code. Its limitation is that this tidy dataset hides the messiness of real production data. Practitioners treat the strong score as a teaching milestone rather than a realistic benchmark.

Case Studies in Multi-Class Prediction

Case Study: Predicting Student Program Choice

Building on those examples, researchers faced the problem of explaining why students enter general, academic, or vocational programs. They built and fit a this approach model on 200 high-school students using writing score and socioeconomic status as predictors (UCLA OARC). The solution used the academic track as the reference and reported relative risk ratios for each contrast. Results showed a higher writing score increased the relative risk of the academic program over the vocational one. The readable ratios gave counselors a clear, evidence-based way to discuss program fit. The limitation is the small sample of 200 cases, which widens confidence intervals and weakens rare contrasts. The authors cautioned against over-interpreting effects that lacked statistical significance.

Case Study: Clinical 30-Day Readmission Categories

A hospital analytics group needed to predict patient readmission risk categories from clinical records. They trained and compared a logistic regression model against a neural network on the same 30-day readmission task (healthcare modeling research). The study found neural networks beat logistic regression in only about 60 percent of cases, with a mean AUC gain near 0.03. Given that slim margin, the team kept the interpretable logistic model for clinical deployment. Transparent coefficients let clinicians audit why a patient landed in a high-risk tier. The limitation is the small accuracy sacrifice, which matters when even tiny gains carry clinical value. The group documented the trade-off so reviewers could revisit the choice as data grew.

Case Study: Diagnostic Category Prediction in Medicine

Diagnosticians wanted to assign patients to one of several diagnosis categories from routine test results. They built a the multinomial model model that predicted three or more diagnostic classes from laboratory predictors (ScienceDirect overview). The solution exposed which test values pushed a patient toward each diagnostic group. To keep estimates stable, the team enforced a rule of at least 10 outcome events per predictor variable. The interpretable output supported triage decisions that clinicians could question and defend. The limitation is that rare diagnoses lacked enough cases, so their error rates tended to increase. The team merged sparse categories and flagged low-confidence predictions for manual review.

Common Questions About Multinomial Logistic Regression

Anchor and Link Map