What Are Large Language Models (LLMs)? Transformer Architecture and Mathematical Principles of Operation

The technical definition of what an LLM is refers to deep learning models that learn the statistical structure of language from large amounts of textual data and can generate new text based on the probability distributions they have learned. LLM is an abbreviation for **Large Language Model** and is used as **Büyük Dil Modeli** in Turkish.

An LLM is not just software that memorizes words. During training, it represents the relationships between symbols within vast amounts of text through mathematical weights. When a user sends a prompt, the model breaks down the given context into smaller pieces called tokens and calculates a probability distribution for the next token. The generation process proceeds by sequentially performing these predictions.

Therefore, **LLM** does not represent the entire artificial intelligence ecosystem. Artificial intelligence is a broader concept; it encompasses many fields such as machine learning, computer vision, robotics, speech systems, and language models. An LLM, on the other hand, is a specific class of models developed for natural language processing and generation. In other words, **the difference between LLM and artificial intelligence** is that one refers to a broad technological field, while the other refers to a specific model approach within that field.

What does LLM stand for and what is a large language model?

LLM stands for **Large Language Model**. The term "Large" is evaluated within a technical framework that refers not only to the model's file size but also to the scale of its parameters, the scope of its training data, and its computational requirements.

A **large language model** learns patterns in texts during training, thereby creating a mathematical structure about the language's syntax, word relationships, context, and various knowledge representations. The model can contain millions, billions, or even larger scales of parameters. These parameters are numerical values that are updated during the training process.

The fundamental principle of how LLMs work is probabilistic prediction. In a simplified form, the model's objective can be expressed as follows:

P(wₜ | w₁, w₂, ..., wₜ₋₁)

This expression represents the probability of the next symbol appearing given the previous symbols. At each generation step, the model creates a probability distribution among possible tokens and determines the next token based on the chosen method.

This mechanism does not mean that the LLM "thinks" about the text consciously like a human. The operation performed by the model is to make probabilistic calculations based on the parameters learned during training and the current context.

The relationship between LLM and artificial intelligence

Although the terms "LLM and artificial intelligence" are sometimes used interchangeably in daily conversation, they are not technically the same concept. Artificial intelligence can be considered a superordinate term. LLM, on the other hand, specifically defines models within this field that focus on processing and generating human language.

For example, an image classification system might be an AI application designed to recognize objects in images, but it is not an LLM. In contrast, large-scale language models that perform text generation, summarization, question answering, code generation, or information processing through natural language can fall into the LLM category.

This distinction also resolves the fundamental conceptual confusion encountered in searches for **LLM vs AI difference**: Every LLM is part of an artificial intelligence system; however, not every artificial intelligence system is an LLM.

What are LLM models?

LLM models can be developed by different companies, research teams, and open-source communities using various architectures and training strategies. Names like the GPT family, Llama family, Gemini, and Claude are frequently encountered examples in the large language model ecosystem.

Here, it is necessary to differentiate between the model name and the application. For example, a chat application that users interact with directly is not the same as the underlying language model running in the background. The **relationship between LLM and ChatGPT** can be understood through this distinction: While ChatGPT is considered an AI product and an interaction layer, the specific model versions behind it may leverage LLM technology.

When examining **large language model examples**, it is not sufficient to look only at the size of the model. The training method, model architecture, context capacity, purpose of use, licensing conditions, inference cost, and performance on specific tasks should also be evaluated.

How do LLMs work?

The answer to the question of how LLMs work can be broken down into several basic stages: converting text into tokens, mapping tokens to numerical representations, calculating relationships within the context via the Transformer architecture, and probabilistically predicting the next token.

A sentence entered by the user is not directly fed into the model word by word. First, a process called **tokenization** is applied. A tokenizer divides the text into smaller units based on the model's vocabulary. These units can sometimes be a full word, sometimes part of a word, or sometimes punctuation.

The numerical IDs of the tokens are then converted into high-dimensional vector representations via embedding layers. The model processes the relationships within the language through these vectors.

At this stage, the Transformer architecture comes into play. Specifically, the **Self-Attention** mechanism helps the model evaluate the current context by calculating the relationships between tokens in a sequence. Thus, relationships between different parts of a sentence can be represented mathematically.

The output generated by the model is not directly pulled from a database as a "ready answer." Generation occurs based on the calculated distribution for possible next tokens at each step. Therefore, the same prompt can yield different answers depending on the model used and the generation parameters.

How is an LLM made?

The answer to the question of how an LLM is made refers to a multi-stage training process rather than the execution of a single algorithm. Building a large-scale model requires extensive datasets, a tokenizer, model architecture, high computational capacity, and long training processes.

In the basic process, text data is prepared, tokenized, and converted into a format that the model can learn from. The model then undergoes a large-scale **pre-training** process to learn patterns in the language. In subsequent stages, methods such as **fine-tuning**, Supervised Fine-Tuning (SFT), RLHF, or DPO can be used to improve the model's behavior and response quality for specific tasks.

Therefore, the question of **how LLM training is done** cannot be explained merely by loading data and running a model. Data quality, model architecture, number of parameters, training objective, hardware infrastructure, and the purpose for which the model will be used after training are all evaluated together.

The real turning point for understanding LLM technology emerges here: the core mechanism that enables the model to generate text is the Transformer architecture's ability to mathematically process relationships within a context. This architecture and the Self-Attention mechanism form the technical basis of how large language models work.

Transformer Architecture and Self-Attention Mechanism

One of the most important turning points in LLM architecture is the Transformer approach. The work **"Attention Is All You Need"** published by Vaswani and colleagues in 2017 introduced an architecture that centered the attention mechanism in processing sequential data. This approach was a significant step towards overcoming the sequential processing limitations of previously widely used RNN and LSTM-based methods.

It is not enough for a language model to evaluate words individually. The meaning of a sentence depends on the relationships between words. The Transformer architecture mathematically calculates these relationships via the **Self-Attention** mechanism.

Why were RNNs and LSTMs not sufficient?

Before the Transformer, recurrent neural networks like RNNs and LSTMs held an important place in natural language processing systems. These models could process text sequentially, transferring information obtained from previous steps to subsequent steps.

However, this approach had a fundamental limitation: the order of operations was largely interdependent. In long sequences, it could become difficult to establish an effective connection between information at an early position and later information.

For example, in a long sentence, there might be many tokens between the subject and the verb later in the sentence. As it became harder for the model to correctly carry these distant relationships, the contextual information could also weaken.

The Transformer approach took a different path by centering the Attention mechanism, which allows for a more parallel calculation of relationships across the entire sequence.

What is Self-Attention?

**Self-Attention** is a mechanism that calculates the relationship of each token in a sequence with other tokens. The "self" in this context refers to attention being established among elements within the same sequence.

For each token in a sentence, the model can calculate how relevant other tokens are. Thus, it can evaluate the meaning of a word not only from immediately adjacent words but also from information coming from more distant parts of the sentence.

The mathematical basis of the Self-Attention mechanism involves three different representations:

• **Query (Q):** Represents what information the current token is looking for.

• **Key (K):** Represents the features each token possesses and that are compared with the query.

• **Value (V):** Carries the information to be transferred as a result of attention.

The basic Attention operation is expressed by the following equation:

Attention(Q, K, V) = softmax(QKᵀ / √dₖ)V

Here, the matrix multiplication between Q and K produces similarity or relationship scores between tokens. These values are scaled, passed through a softmax function to be converted into weights, and the information in the V matrix is combined with these weights.

Through this mechanism, the model can calculate which information within the context carries more weight for the current token.

Difference between Tokenization and Embedding

To understand how an LLM works at a technical level, it is necessary to distinguish between the concepts of tokenization and embedding.

**Tokenization** is the process of dividing text into tokens that the model can process. For example, a single word can be a token; however, depending on the tokenizer and vocabulary used, a word can also be split into multiple parts.

**Embedding**, on the other hand, is the conversion of these tokens into mathematical vectors. The model does not directly process natural language in the form of words as humans perceive them. Tokens are converted into numerical representations, and the neural network performs calculations on these representations.

These vectors are one of the fundamental inputs for the model to learn relationships within the language. As the model's parameters are updated during the training process, token representations can more effectively reflect usage patterns in the language.

Why is Positional Encoding necessary?

The Self-Attention mechanism can calculate relationships between tokens; however, when only looking at the content representations of tokens, position information in the sequence must be expressed separately.

In sentences like "Ali saw Ayşe" and "Ayşe saw Ali," although the same words are present, the order of the words changes the meaning. For the model to understand this difference, the positions of the tokens in the sequence must be represented.

In the Transformer architecture, this problem is addressed through **Positional Encoding** or, more generally, positional information representations. Thus, the model can evaluate not only what the token is but also its position within the sequence.

How positional information is added to the model can vary depending on the architecture used. In the classical Transformer design, a positional encoding approach based on sine and cosine functions was used. In subsequent language model architectures, different positional representation methods have been developed.

How does Multi-Head Attention work?

The Transformer architecture does not consist of just a single Attention calculation. **Multi-Head Attention** allows multiple Attention heads to operate in parallel.

Each attention head can be learned to focus on different relational patterns between tokens. While one head might give weight to a syntactic relationship, another head might represent a different semantic connection more strongly.

The outputs of the calculated heads are combined and passed to subsequent Transformer layers. This allows the model to evaluate the same text from different relational perspectives.

This structure demonstrates that the LLM architecture is not just a simple "word predicting" system. Many mathematical transformations, weight matrices, and layers work together within the model.

The Birth of an LLM: Training Stages

The capabilities of an LLM do not stem solely from its architecture. How the model is trained, with what data, and for what purpose, also determines its resulting behavior.

Pre-training: The basic training of the language model

**Pre-training** is the fundamental learning phase of large language models. The model tries to learn patterns in the language from very large text datasets.

In this phase, the model's primary task for most modern autoregressive LLMs is to predict the next token by looking at previous tokens. The difference between the model's prediction and the actual token is calculated via a loss function, and parameters are updated using backpropagation.

A simplified flow can be imagined as follows:

Text → Tokenization → Embedding → Transformer layers → Next token prediction → Loss calculation → Parameter update

When this process is repeated over a very large number of examples, the model gradually begins to represent the statistical structures of language more effectively.

What do parameters mean?

In LLMs, **parameters** refer to numerical values learned during training. The model's weights and, in some architectures, bias values are fundamental mathematical components that determine how inputs are transformed.

An increase in the number of parameters alone does not guarantee that a model will be more successful in every task. Data quality, training method, model architecture, computational budget, and inference strategies also affect performance.

Therefore, the "biggest model is the best model" approach is technically insufficient.

Fine-Tuning and SFT

After pre-training, **Fine-Tuning** can be applied to make the model behave more controllably in specific tasks.

In the Supervised Fine-Tuning (SFT) phase, the model is presented with specific inputs and the corresponding expected outputs. The model is then re-trained to adapt to the specified behavior based on these examples.

For example, the goal might be for a model to produce technical documentation, respond in a specific format, or adapt better to a particular task domain.

This process is not the same as building an LLM from scratch. Fine-Tuning focuses on modifying the parameters of an existing model for a specific purpose.

RLHF and DPO

A language model merely predicting the correct token does not mean it will provide answers that meet user expectations. Methods that leverage human evaluations have been developed to ensure responses are helpful, safe, and preferred.

**RLHF (Reinforcement Learning from Human Feedback)** is one of the approaches aimed at improving model behavior by leveraging human feedback. Responses evaluated by humans can create a signal for what kind of outputs the model should prefer.

**DPO (Direct Preference Optimization)**, on the other hand, is a method aimed at directly optimizing the model's tendency to produce preferred responses using preference data.

It is important to distinguish these training stages from each other:

How do language models learn?

Language models do not learn by studying like humans. During training, the model's parameters are updated using a mathematical optimization method to reduce prediction error.

The model makes a prediction about which token should come after a given token. The difference between the actual data and the prediction is measured by a loss function. Then, gradients are calculated to determine which direction the parameters should be changed in.

In a model with billions of parameters, this process can require enormous computational resources. When training is complete, the model becomes a neural network that distributes and represents the patterns in the training data within its parameters.

This mechanism reveals one of the most important distinctions related to **LLM technology**: The model does not necessarily contain a traditional "answer database" to be retrieved. Generation occurs through learned parameters and the given context.

Applications of LLMs

LLM applications are not limited to chat applications. They can be used in numerous tasks such as text generation, summarization, translation, classification, information extraction, code generation, document analysis, and customer service.

An **LLM-based application** can be more comprehensive than using the base model alone. The application may include databases, APIs, search systems, RAG components, security layers, and specific business rules.

For example, a system operating in the legal field might use a language model supported by legislation and case law documents. The concept encountered in searches like "what is an LLM lawyer" typically refers to such legal-focused AI applications; the LLM itself is not legally a lawyer.

**Where are LLMs used?**

• Content and text generation

• Code writing and code explanation

• Document summarization

• Customer support systems

• Text classification

• Information extraction

• Search and question-answering systems

• Educational applications

• Assistance systems for specialized fields like law and finance

The success of these applications does not depend solely on the chosen model. Data quality, prompt design, context management, verification mechanisms, and application architecture are also decisive.

How are LLMs used?

The answer to the question of how LLMs are used varies depending on the purpose of use. In simple usage, a user sends a prompt directly through a chat interface. In more advanced applications, the model can be connected to software via an API.

For example, an enterprise application might first classify the user's question, find relevant documents, pass them to the model as context, and then put the generated answer through a verification layer.

Here, **Prompt Engineering** also comes into play. A well-designed prompt can help the model understand the task, context, output format, and constraints more clearly.

The scope of what can be done with LLMs is therefore not limited to just writing text. The model can also serve as the language processing layer of a larger software architecture.

Technical Limitations of LLMs

Despite their powerful language generation capabilities, LLMs are not infallible information engines. The probabilistic nature of the model's operation can sometimes lead it to produce responses that are factually incorrect or require verification.

This problem is called **hallucination**. The model can generate information, sources, or explanations that appear linguistically convincing but are actually false.

The limitations of the context window also pose another technical constraint. The amount of tokens a model can evaluate during a single operation varies depending on the architecture and model version used. For very long documents, which information is included in the context can directly affect the quality of the model's response.

At this point, architectures like RAG can help the model generate responses by retrieving relevant content from external knowledge sources. Fine-Tuning, on the other hand, solves a different problem; it aims to change the model's behavior or its ability in specific tasks.

Key Distinction Between LLM, RAG, and Fine-Tuning

RAG and Fine-Tuning are not direct alternatives to each other. Both can be used together in an application. RAG addresses the problem of accessing external information, while Fine-Tuning can focus on the model's behavior or its ability in specific tasks.