Topic Modeling Techniques for 2026: Seeded Modeling, LLM Integration, and Data Summaries

1.

Topic modelling has recently progressed in two directions. The improved statistical methods stream of Python packages focuses on more robust, efficient, and preprocessing-free models, producing fewer junk topics (e.g., FASTopic). The opposite relies on the ability of generative language models to extract intuitively comprehensible topics and their descriptions (e.g., TopicGPT [6], LlooM [5]).

Due to research on statistical methods for modelling text representations from transformers, junk topics are the exception somewhat than the norm in newer models. Meanwhile, novel, LLM-based approaches are difficult our long-standing views about what a subject model is and what it may well do. Human-readable topic names and descriptions at the moment are becoming increasingly more an expected results of a well-designed topic modelling pipeline.

As exciting as these developments are, topic modelling is way from being a solved problem. Neural topic models will be somewhat unstable and sometimes hard for users to trust due to their black-box nature. LLM-powered methods produce impressive results, but can at times raise questions on trust, as a consequence of hallucinations and sensitivity to semantically irrelevant changes in input. This is very an issue for the banking sector, where (un)certainty is crucial. Running large language models can be an enormous infrastructural and computational burden, and might find yourself costing large sums of cash even for smaller datasets.

Our previous tutorial provides an in depth introduction to how LLMs enhance traditional topic modeling by robotically labeling topic names. In this text, we mix current topic modeling methods with targeted LLM assistance. In our view, a mixture of recent advances in language modeling and classical machine learning can provide users with one of the best of each worlds: a pipeline that mixes the capabilities of huge language models with the computational efficiency, trustworthiness, and stability of probabilistic ML.

This text explains three fresh topic-modelling techniques that ought to be a part of the NLP toolkit in 2026. We are going to work out:

We illustrate these on the central bank communication speeches corpus from the European Central Bank. Such a text is long, rigorously structured, and highly repetitive — exactly the type of knowledge where standard topic models struggle and where interpretability is crucial. By combining seeded topic modelling with LLM-assisted document summarization and evaluation, we show tips on how to extract focused, stable, and economically meaningful topics without compromising transparency or scalability.

2. Example Data

We use the press conference communications of the European Central Bank (ECB) as example text data. Since 2002, the ECB’s Governing Council has met on the primary Thursday of every month, and its communication of the meeting’s consequence follows the two-step structure ([2]).

For this text, we use the introductory statements, scraped directly from the ECB website (released with a flexible data licence). The dataset comprises 279 statements, and here’s what it looks like:

3. Seeded Topic Modelling 

Traditionally, topic models deal with identifying probably the most informative topics in a dataset. A naive approach practitioners take is to suit a bigger model, then, often manually, filter out topics irrelevant to their data query.

In some methods, this implies choosing a set of keywords that reflect your query. But within the framework we explore in this text, you possibly can specify your interest in free-text using a seed phrase that tells the model what to deal with.

3.1 KeyNMF Model

We are going to use the cutting-edge contextual KeyNMF topic model ([3]). It’s, in lots of facets, very just like older topic models, because it formulates topic discovery by way of matrix factorization. In other words, when using this model, you assume that topics are latent aspects, that your documents contain to a lesser or greater extent, which determine and explain the content of those documents. 

KeyNMF is contextual because, unlike older models, it uses context-sensitive transformer representations of text. To know how seeded modelling works, we’d like to achieve a basic understanding of the model. The modelling process happens in the next steps:

3.2 Seeded KeyNMF 

The overall KeyNMF, while perfectly adequate for locating topics in a corpus, will not be probably the most suitable selection if we’d like to make use of the model for a selected query. To make this occur, we first should specify a seed phrase, a phrase that minimally indicates what we’re inquisitive about. For instance, when analysing the ECB communication dataset, this might be .

As sentence-transformers can encode this seed phrase, we are able to use it to retrieve documents which might be relevant to our query:

The benefits of this approach are that it’s:

3.3 Learn how to use Seeded KeyNMF

KeyNMFand its seeded version can be found on PyPI within the Turftopic package, in a scikit-learn-compatible form. To specify what you might be inquisitive about, simply initialize the model with a seed phrase:

from sentence-transformers import SentenceTransformer
from turftopic import KeyNMF

# Encode documents using a sentence-transformer
encoder = SentenceTransformer("paraphrase-mpnet-base-v2")
embeddings = encoder.encode(documents, show_progress_bar=True)

# Initialize KeyNMF with 4 topics and a seed phrase
model = KeyNMF(
 n_components=4,
 encoder=encoder,
 seed_phrase="Expansion of the Eurozone",
 seed_exponent=3.0,
)

# Fit model 
model.fit(corpus)

# Print modelled topics
model.print_topics()

We will see that the model returns topic IDs with typical keywords which might be clearly related to the Euro and the Eurozone:

4. LLM-assisted Topic Modeling

Finding interpretable topics from a corpus is a difficult task, and it often requires greater than only a statistical model that finds patterns within the raw data. LLMs serve topic modelling in two important areas:

In the next text, we are going to now explore 1) how LLMs improve processing documents for a subject model and a couple of) how generative models improve understanding and interpreting the model results.

4.1. Document Summarization 

Considered one of the Achilles’ heels of the sentence transformers we often use for topic evaluation is their short context length. Encoder models that may read considerably longer contexts have rarely been evaluated for his or her performance in topic modeling. Subsequently, we didn’t know whether or how these larger transformer models work in a subject modelling pipeline. One other issue is that they produce higher-dimensional embeddings, which regularly negatively affect unsupervised machine learning models ([4]). It may either be because Euclidean distances get inflated in higher-dimensional space, or since the variety of parameters surges with input dimensionality, making parameter recovery tougher.

We will solve these issues by:

Let’s now summarise the trade-offs of using LLM-generated summaries in topic modelling in the next image.

The really helpful strategy for LLM-assisted document preprocessing is a two-step:

4.1.1. Document Summarization in Code

Let’s now take a look at how we are able to summarize documents using an LLM. In this instance, we are going to use GPT-5-nano, but Turftopic also allows running locally run open LLMs. We recommend using open LLMs locally, if possible, as a consequence of lower costs and higher data privacy.

import pandas as pd
from tqdm import tqdm
from turftopic.analyzers import OpenAIAnalyzer, LLMAnalyzer

# Loading the info
data = pd.read_parquet("data/ecb_data.parquet")
content = list(data["content"])

# We write a prompt that may extract the relevant information
# We ask the model to separate information to key points in order that 
# they turn out to be easier to model

summary_prompt="Summarize the next press conference from 
the European Central Bank right into a set of key points separated by 
two newline characters. Reply with the summary only, nothing else. 
n {document}"

# Formalize a summarized
summarizer = OpenAIAnalyzer("gpt-5-nano", summary_prompt=summary_prompt)
summaries = []

# Summarize dataframe, track code execution 
for document in tqdm(data["content"], desc="Summarising documents..."):
    summary = summarizer.summarize_document(document)
    # We print summaries as we go as a sanity check, to be certain that 
    # the prompt works
    print(summary)
    summaries.append(summary)

# Collect summaries right into a dataframe
summary_df = pd.DataFrame(
    {
        "id": data["id"],
        "date": data["date"],
        "creator": data["author"],
        "title": data["title"],
        "summary": summaries,
    }
)

Next, we are going to fit an easy KeyNMF model on the important thing points in these summaries, and let the model discover the variety of topics using the .  This approach works thoroughly on this case, but watch out that automatic topic number detection has its shortcomings. Try the Topic Model Leaderboard to achieve more information on how models perform at detecting the variety of topics.

import numpy as np
import pandas as pd
from sentence_transformers import SentenceTransformer
from turftopic import KeyNMF

# Create corpus from text summaries (not original texts)
corpus = list(summary_df["summary"])

# Collect key points by segmenting at double line breaks
points = []

for doc in corpus:
  _points = doc.split("nn")
  doc_points = [p for p in _points if len(p.strip().removeprefix(" - "))]
  points.extend(doc_points)

# Tell KeyNMF to robotically detect the variety of topics using BIC
model = KeyNMF("auto", encoder="paraphrase-mpnet-base-v2")
doc_topic = model.fit_transform(points)

# Print topic IDs with top words
model.print_topics()

Listed below are the KeyNMF results trained on document summaries:

4.3. Topic Evaluation with LLMs

In a typical topic-analysis pipeline, a user would first train a subject model, then spend time interpreting what the model has discovered, label topics manually, and at last provide a transient description of the kinds of documents the subject comprises. That is time-consuming, especially in corpora with many identified topics. 

This part can now be done by LLMs that may easily generate human-readable topic names and descriptions. We are going to use the identical Analyzer API from Turftopic to attain this:

from turftopic.analyzers import OpenAIAnalyzer

analyzer = OpenAIAnalyzer()
analysis_result = model.analyze_topics(analyzer, use_documents=True)

print(analysis_result.to_df())

We apply the analyzer to the introductory statements issued by the ECB, which accompany each monetary policy decision. These statements are prepared rigorously and follow a comparatively standard structure. Listed below are the labelled topic names with their descriptions and top words printed from :

Next, let’s show the prevalence of the labelled KeyNMF’ topic names over time. It’s how intensely these topics were discussed within the ECB press conferences in the course of the last 25 years:

from datetime import datetime
import plotly.express as px
from scipy.signal import savgol_filter

# create dataframe from labelled topics, 
# mix with timestamp from date column
time_df = pd.DataFrame(
    dict(
        date=timestamps,
        **dict(zip(analysis_result.topic_names, doc_topic.T /
                                                doc_topic.sum(axis=1)))
    )
).set_index("date")

# group dataframe to monthly frequency
time_df = time_df.groupby(by=[time_df.index.month, time_df.index.year]).mean()
time_df.index = [datetime(year=y, month=m, day=1) for m, y in time_df.index]
time_df = time_df.sort_index()

# display dataframe with Plotly

for col in time_df.columns:
    time_df[col] = savgol_filter(time_df[col], 12, 2)
fig = px.line(
    time_df.sort_index(),
    template="plotly_white",
)
fig.show()

Here is the labelled topic model dataframe displayed in yearly frequency:

5. Summary

Let’s now summarize the important thing points of the article. The necessities and code for this tutorial are on this repo.

• Seeded KeyNMF topic model combines text prompts with the newest topic model to pay attention modelling on a certain problem.
• Summarizing data for topic modeling reduces training time, but it surely has drawbacks that ought to be considered in a project.
• The Tutftopic Python package implements systematic descriptions and labels with recent LLMs right into a topic modelling pipeline.

References 

[1] Taejin Park, Fernando Perez-Cruz and Hyun Song Shin. 2025. . In: BIS Working Papers, No. 1299, 16 October 2025, 26 pp.

[2] Carlo Altavilla, Luca Brugnolini, Refet S. Gürkaynak, Roberto Motto and Giuseppe Ragusa. 2019. Measuring euro area monetary policy. In: , Volume 108, pp 162-179.

[3] Ross Deans Kristensen-McLachlan, Rebecca M.M. Hicke,  Márton Kardos, and Mette Thunø. 2024. In: CHR 2024: Computational Humanities Research Conference, December 4–6, 2024, Aarhus, Denmark.

[4] Márton Kardos, Jan Kostkan, Kenneth Enevoldsen, Arnault-Quentin Vermillet, Kristoffer Nielbo, and Roberta Rocca. 2025. . In: Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 633–666, Vienna, Austria. Association for Computational Linguistics.

[5] Martin Feldkircher, Petr Koráb and Viktoriya Teliha. 2025. In: CAMA Working Paper Nr. 35/2025.

[6] Michelle S. Lam, Janice Teoh, James A. Landay, Jeffrey Heer, and Michael S. Bernstein. 2024. . In: Proceedings of the 2024 CHI Conference on Human Aspects in Computing Systems (CHI ’24). Association for Computing Machinery, Latest York, NY, USA, Article 766, 1–28. https://doi.org/10.1145/3613904.3642830.

[7] Chau Minh Pham, Alexander Hoyle, Simeng Sun, Philip Resnik, and Mohit Iyyer. 2024. TopicGPT: A Prompt-based Topic Modeling Framework. In Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pages 2956–2984, Mexico City, Mexico. Association for Computational Linguistics.