At TechEd Berlin, SAP announced SAP-RPT-1. Since then, I often hear questions like: “Is this model an LLM?“, “How is it different from Joule?“
In fact, the idea behind SAP-RPT-1 is not completely new. There is a research paper from 2020 titled “RPT: Relational Pre-trained Transformer Is Almost All You Need towards Democratizing Data Preparation”.
In this post, I will not go deep into the SAP-RPT-1 product itself. Instead, I will look at the original RPT paper and explain the architecture behind it. (SAP officially describes SAP-RPT-1 as a “Relational Pretrained Transformer” and positions it as a foundation model for business. The product version is tuned more for real business use cases than the original research model.)
What is In-Context Learning?
The official SAP-RPT-1 page describes it like this:
“SAP-RPT-1 is a relational pretrained transformer model that delivers accurate predictive insights from structured business data. SAP-RPT-1 uses in-context learning, allowing users to provide data records to generate instant, reliable predictions without any model training.”
So, what is in-context learning?
In short, you take a model that is already trained, give it a few example records together with your question, and the model uses the pattern in those examples to produce an answer.
You can think of it like this kind of quiz:
The important point is:
- You are only showing examples.
- You are not changing the model’s internal parameters.
The model was trained before. Now you only give it context (examples) at run time, and it uses that context to reason.
In-Context Learning vs “Learning”
In-context learning is not the same as “learning” in the usual machine learning sense.
In normal “learning” or “training”:
- The model updates its parameters using training data.
- This happens in pre-training or fine-tuning.
In in-context learning:
- The model parameters are not updated.
- You only change the input (the prompt), not the model itself.
- This technique is often called few-shot prompting.
On the other hand, the term few-shot learning is usually used when you actually train or fine-tune the model again. But you use only a small number of labeled examples.
In in-context learning, the real “learning” (pre-training, fine-tuning) is already done. The model has become a kind of huge pattern recognition machine. When you show a few examples in the prompt, it behaves as if it learned a new task on the spot and gives reasonable answers. We don’t fully see how it works internally (it feels like a black box), but we can use this behavior.
What is Relational Pre-trained Transformer (RPT)?
Modern large language models (LLMs) are trained with Next Token Prediction. They read a huge amount of text and learn to predict the next token (word, subword, etc.) from the previous tokens. By doing this, they learn grammar, vocabulary, how to follow instructions, and many other patterns in natural language. The interesting part is when the model is trained on a lot of data, it can guess or infer information that was not explicitly given, and be used for many different tasks. These models are called foundation models, they are pre-trained on broad data and can be adapted to many downstream tasks.
Relational Pre-trained Transformer (RPT) applies a similar idea, but to relational / table data, not free text. RPT was originally proposed to automate data preparation tasks such as data cleaning, filling, missing values, and so on.
RPT takes pairs of attribute [A] and value [V] as input. For example, a tuple (row) can be represented like this:
[A] name [V] Michael Jordan [A] expertise [V] Machine Learning [A] city [V] Berkeley
This is one record (one row) written as a sequence. RPT then masks either an attribute or a value and tries to predict it.
- Masking an attribute name
Hide the attribute name and let the model guess it from the rest.
Example: [A] name [V] Michael Jordan -> [A] [M] [V] Michael Jordan - Masking an attribute value
Hide the value and let the model predict what should be there.
Example: [A] expertise [V] Machine Learning -> [A] expertise [V] [M]
By training on many tuples like this, as a result, RPT becomes a model specialized for table data preparation, such as:
- data cleaning (detecting and fixing wrong values),
- missing value imputation (filling empty cells),
- schema matching (deciding which value belongs to which column).
So you can think of RPT not as a model that writes the next sentence like LLM, but as a model that: “Looks at one row of a table and is very good at fixing or completing it.“
Why Is SAP-RPT-1 Called a “Predictive Model”?
This tuple-based training is a great fit for tabular data (Attributes = columns in a table, Values = cells in each row). RPT models learn the patterns of (column, value) pairs very well. After pre-training, they can look at a new record (row) and ask “What value is likely for this column?”.
SAP-RPT-1 is described as a “predictive model” because it can use existing records as teachers via in-context learning. When we call the API, we can send some existing records (historical data) and a target record with some missing values. The model reads the patterns in the context records. Then it predicts the missing cell(s) in the target record. So SAP-RPT-1 behaves like a predictive model for tables.
In short:
- RPT (paper version) is a data preparation model that fills and fixes missing or noisy values in tuples.
- SAP-RPT-1 (product version) is a foundation predictive model for tabular business data, built on the RPT idea and extended for business use.
The architecture comes from the RPT family. On top of that, SAP-RPT-1 can do classification and regression on table data via in-context learning, which is why it is promoted as a predictive model.
Conclusion
Finally, SAP-RPT-1 has a Playground that you can try. On the official website, click “Try SAP-RPT-1 for free” and test it with your own data or a simple example. With a GUI, you can upload a small table and quickly see what inputs you give and what predictions come back. If you read the RPT paper and then play with the Playground, your understanding of SAP-RPT-1 will grow much faster.
#SAPCHANNEL