Output Layer

The Hidden Layer article ended at exactly this point: after all that progressive transformation — raw pixels into edges, edges into shapes, shapes into recognizable parts — something has to take that final, abstract representation and turn it into an actual, usable answer. That’s the job of the output layer.

The simple definition

The output layer is the final layer of a neural network, and its job is to convert whatever the last hidden layer produced into the network’s actual prediction, in the exact format the task requires. It’s structurally similar to a hidden layer — its nodes perform the same weighted-sum-plus-bias-plus-activation calculation described in the Node article — but its specific size and activation function are dictated entirely by what kind of answer the task needs, rather than being a free design choice the way a hidden layer’s size often is.

Why the output layer’s shape depends entirely on the task

This is the single most important thing to understand about the output layer, and it directly echoes the Prediction article’s discussion of how a model’s raw output takes different forms for different tasks. The output layer isn’t one universal shape — it’s built to match exactly what the task requires:

Regression tasks (predicting a number, like house price) typically use an output layer with exactly one node, whose final value, often passed through minimal or no activation function, directly represents the predicted number.
Binary classification tasks (spam or not-spam) also typically use one node, but its output gets passed through an activation function that squashes the result into a probability between 0 and 1 — recall the classifier probability outputs described in the Prediction article.
Multi-class classification tasks (cat vs. dog vs. bird) use one node per possible category — three nodes for three animal categories — with an activation function (commonly softmax, mentioned in the Prediction article’s discussion of next-token prediction) that converts all the nodes’ raw values into a full probability distribution across every category, summing to 100%.

flowchart LR
    A[Last Hidden Layer's output] --> B{What kind of task?}
    B -->|Regression| C[1 output node: a number]
    B -->|Binary classification| D[1 output node: a probability 0-1]
    B -->|Multi-class classification| E[N output nodes: probability per category]

ANALOGY vs. TECHNICAL REALITY

Analogy: Think of a translator at the very end of a long research process, whose job is to take all the accumulated findings and analysis from a team of specialists (the hidden layers) and condense them into the exact final format a client actually needs — a single recommended number, a yes/no verdict, or a ranked list of options, depending on what was originally asked for.

Where this breaks down: A human translator applies judgment about how best to present findings for a specific audience. The output layer applies a fixed, predetermined formula — chosen by the engineer, in advance, based on the task type — with no judgment involved in the moment; the same combination of node count and activation function gets applied identically to every single prediction the network ever makes.

Finish the loan example at the output layer

The hidden layer sends [0.59, 0.58]. The output node uses weights [1.2, 1.0] and bias -0.7:

output logit = (0.59 × 1.2) + (0.58 × 1.0) - 0.7
             = 0.708 + 0.58 - 0.7
             = 0.588

The number 0.588 is a logit—a raw score, not yet a probability. A sigmoid activation converts it:

sigmoid(0.588) ≈ 0.643
approval probability ≈ 64.3%

If the application’s chosen threshold is 50%, the final class is “approve.” If policy requires a 70% threshold, the same 64.3% score becomes “do not automatically approve.” The network output and the business decision are related but not identical.

flowchart LR
    A[Hidden values: 0.59, 0.58] --> B[Weighted sum + bias]
    B --> C[Raw logit: 0.588]
    C --> D[Sigmoid]
    D --> E[Probability: 64.3%]
    E --> F[Apply decision threshold]

Match the output layer to the task

Task	Typical output shape	Typical final activation	Example interpretation
Regression	One or more numbers	Linear/no bounded activation	Predicted price = ₹42 lakh.
Binary classification	One number	Sigmoid	0.643 probability of approval.
Single-label multiclass	One value per class	Softmax	Cat 0.70, dog 0.20, bird 0.10.
Multilabel classification	One value per label	Sigmoid for each label	Photo contains person 0.92 and bicycle 0.81.

The output design must also match the label format and loss function. A mismatch can make training mathematically unsuitable even if the code runs.

From output to usable prediction

The output layer creates model scores. A production system may still apply thresholds, ranking, policy rules, calibration, or human review before acting. For a language model, the output layer produces a score for every token in the vocabulary; softmax turns those scores into probabilities, and a decoding procedure chooses the next token.

A concrete example, layered

Simple example: predicting one house price

The house-price network has an output layer containing exactly one value.

Hidden representation → output calculation → predicted price

After all hidden layers finish transforming the house features, the output calculation produces the predicted price. Because this is regression, the model may use a linear output rather than converting the value into a probability.

Production example: choosing GPT-3’s next token

At the end of GPT-3’s hidden layers, the final representation is projected to one raw score for every token in its 50,257-token vocabulary, as documented in OpenAI’s published paper.

The steps are:

Produce 50,257 raw token scores called logits.
Use softmax to convert them into a probability distribution.
Apply a decoding method to select the next token.
Add that token to the sequence and repeat the process.

The output side is tied to the vocabulary size, while the internal hidden dimension is a different architectural quantity.

What happens differently here compared to a hidden layer

It’s worth being explicit about this distinction, since output layers and hidden layers can otherwise look structurally similar. A hidden layer’s size is a genuine design choice — an engineer can pick 4 nodes, or 400, largely based on capacity and experimentation, as covered in the Layer article. An output layer’s size is not a free choice at all — it’s fixed by the number of things the task needs predicted (one number, one probability, or one probability per category). Similarly, a hidden layer’s activation function is chosen mainly for good training behavior (a topic the next two articles in this phase cover fully), while an output layer’s activation function is chosen specifically to produce output in the correct format for the task — a probability, a raw number, or a full distribution across categories.

Focused infographic: how a language model produces the next token

Suppose the prompt ends with “The sky is”. The last hidden representation reaches the language model’s output projection:

flowchart LR
    A[Final hidden vector] --> B[One score per vocabulary token]
    B --> C[Softmax probabilities]
    C --> D[blue 0.62]
    C --> E[clear 0.11]
    C --> F[falling 0.01]
    D --> G[Decoding chooses next token]

The probabilities above are illustrative, not reported values from a particular GPT response. After one token is selected, it is appended to the sequence and the model runs again to predict the following token.

Real-model connection: GPT-2’s 50,257-way output

The GPT-2 technical report states that GPT-2 used a vocabulary of 50,257 tokens. Conceptually, at each generation step its output side must assign a score across those vocabulary choices before decoding selects a token.

final hidden representation
        ↓
50,257 token scores
        ↓ softmax
50,257 probabilities
        ↓ decoding
one next token

This is why a language model’s output layer is very different from the loan network’s single sigmoid output, even though both convert a hidden representation into task-specific scores.

Common misconception

A frequent beginner assumption: that the output layer is where the network “decides” or “understands” the final answer, doing some special, extra-intelligent computation beyond what hidden layers do. In reality, as this article has shown, the output layer performs the exact same basic node calculation as any hidden layer — its real distinction isn’t computational sophistication, but its specific role: taking whatever abstract representation the hidden layers have built and reshaping it into the precise format the task calls for. All the genuinely complex pattern-building already happened in the hidden layers before the data ever reached here.

Where this fits in what comes next

You now have the full anatomy of a neural network: an Input Layer that holds raw data, Hidden Layers that progressively build abstract representations, and an output layer that converts those representations into a usable prediction. The next article, Activation Function, goes back and explains in full detail something referenced constantly throughout this phase but never fully unpacked — the specific mathematical step, applied inside every node, that this whole phase has been quietly relying on.

In one sentence

The output layer converts a network’s final, abstract internal representation into the actual prediction a task requires — its size and activation function fixed entirely by what kind of answer is needed, not by free design choice the way a hidden layer’s structure often is.

Author: TechByteByByte Editorial Team
Reviewed by: TechByteByByte Admin
Published: August 31, 2026
Last reviewed: August 31, 2026