Softmax Calculator

The softmax calculator converts a vector of raw neural network scores — called logits — into a clean probability distribution that sums to exactly 1. You paste a comma-separated list of logits such as 2.0, 1.0, 0.1, optionally set a temperature, and the tool instantly returns the probability for every class, the predicted class (the one with the highest probability), the percentage confidence, and the entropy of the distribution in bits. It is the exact computation that sits at the output of nearly every classification network, transformer language model, and reinforcement learning policy.

Logits are the unnormalized outputs of the final linear layer. On their own they can be any real number — positive, negative, large, or small — and they do not add up to anything meaningful. The softmax function fixes that by exponentiating each logit and dividing by the sum of all exponentials. Because the exponential is always positive and the values are normalized by their total, every output lands in the open interval (0, 1) and the whole vector sums to 1, which is precisely what a probability distribution requires.

This softmax calculator also exposes temperature scaling, a single knob that controls how sharp or smooth the resulting distribution is. A temperature below 1 makes the model more confident (the largest logit dominates), while a temperature above 1 flattens the distribution toward uniform. Temperature is the same parameter you adjust when you tune the "creativity" of a large language model during text generation. By reporting probabilities, the predicted class, and entropy together, the tool lets you build intuition for how logits, temperature, and confidence interact — whether you are debugging a classifier, studying for a machine learning exam, or tuning sampling for an LLM.

The softmax function for class i divides the exponential of that class's temperature-scaled logit by the sum of the exponentials of every class. The temperature T simply divides each logit before exponentiation. This calculator implements exactly that formula in JavaScript, including the standard numerical-stability trick of subtracting the maximum scaled logit before exponentiating — a shift that never changes the result because it cancels in the numerator and denominator, but it prevents overflow when logits are large.

Walking through the steps the code performs: first each logit x is divided by the temperature to give a scaled logit x/T. Then the maximum scaled value is subtracted from every entry for stability. Each shifted value is passed through the exponential function. Those exponentials are summed, and each exponential is divided by that sum to produce a probability. The class with the largest probability is reported as the predicted class, and its probability times 100 is the confidence percentage.

Alongside the probabilities, the tool computes entropy using base-2 logarithms, so the result is expressed in bits. Entropy measures how spread out the distribution is: a perfectly confident one-hot prediction has zero entropy, while a uniform distribution over n classes has the maximum possible entropy of log₂(n) bits. Low entropy means the model is sure about a single class; high entropy means it is hedging across several. Watching entropy change as you adjust temperature is one of the fastest ways to feel what temperature scaling actually does to a model's confidence.

Temperature scaling is the most important control in this softmax calculator after the logits themselves. Dividing every logit by T before exponentiation rescales the gaps between scores. Because the exponential amplifies differences, shrinking those gaps (large T) flattens the output toward a uniform distribution, while widening them (small T) pushes probability mass onto the single highest logit.

Consider the default logits 2.0, 1.0, 0.1. At the standard temperature of T = 1.0, the softmax probabilities are roughly 65.90%, 24.24%, and 9.86%. Lower the temperature to T = 0.5 and the same logits produce a much sharper distribution of about 86.38%, 11.69%, and 1.93% — the top class becomes far more dominant. Raise it to T = 2.0 and the distribution smooths to about 50.17%, 30.43%, and 19.40%, much closer to uniform. The logits never changed; only the temperature did.

This behavior maps directly onto two practical regimes. In large language model sampling, a low temperature (for example 0.2) makes generation focused and deterministic — the model almost always picks its top token — while a high temperature (for example 1.2) makes it diverse and creative at the cost of coherence. In knowledge distillation, a high temperature is applied to a teacher network's logits so the "soft targets" reveal the relative similarities between classes (the so-called dark knowledge), which a student model learns from far more efficiently than from hard one-hot labels. As T approaches 0 the distribution collapses toward a one-hot argmax, and as T grows large it approaches a uniform distribution over all classes. Use the temperature field in this calculator to reproduce all three regimes and watch both the probabilities and the entropy respond.

This softmax calculator surfaces three summary metrics on top of the raw probabilities, and each answers a different question. The predicted class is simply the index of the largest probability — the model's single best guess. Note that indexing is zero-based, so for the input 2.0, 1.0, 0.1 the predicted class is Class 0, the first value, because it carries the highest logit and therefore the highest probability.

The confidence is that winning probability expressed as a percentage. A confidence of 65.90% means the model assigns about two-thirds of the total probability mass to its top class. High confidence is not always reliable — neural networks are famously prone to being overconfident, which is exactly why temperature scaling is also used after training as a calibration technique to make reported confidences match real-world accuracy.

The entropy, reported in bits, captures uncertainty across the whole distribution rather than just the top class. The calculator computes it as the negative sum of each probability times its base-2 logarithm. The table below shows how entropy responds to temperature for the default logits, illustrating that smoother distributions carry more entropy.

For three classes, the maximum possible entropy is log₂(3) ≈ 1.585 bits, reached only when all three probabilities are equal at 33.33%. The T = 2.0 row sits at 1.4806 bits, already close to that ceiling, which confirms the distribution is approaching uniform. Reading these three numbers together gives you a complete picture of both what the model predicts and how sure it is.

Using this softmax calculator takes two inputs. First, type or paste your logits into the text box as a comma-separated list, for example 2.0, 1.0, 0.1. These are the raw scores from the final layer of your network; they can be any real numbers including negatives, and you can enter as many classes as you like. The calculator parses the list, ignores blank or invalid entries, and treats the position of each value as its class index starting from zero.

Second, set the temperature. Leave it at 1.0 for a standard softmax, drop it below 1 to sharpen the distribution toward the top class, or raise it above 1 to smooth the distribution toward uniform. The temperature must be greater than zero; the field enforces a small minimum to avoid dividing by zero. As soon as you change either input, the results update with no button press required.

The output panel reports the predicted class and its confidence percentage prominently, then lists the entropy in bits and the number of classes. Below that, a probability distribution shows a labeled bar for every class with its exact probability and percentage, and the predicted class is highlighted. This makes the tool ideal for students checking hand-computed softmax values, engineers debugging a classifier's output, and anyone tuning LLM sampling temperature. Because every number here is produced by the same exponentiate-and-normalize formula used inside PyTorch, TensorFlow, and JAX, the results are reproducible and match what real frameworks compute.