ibm-granite

/

granite-4.0-h-micro

like 123

Follow

IBM Granite 3.65k

Hi @kalle07 I'm sorry to hear these aren't working for you. Can you provide some more details on the specific GGUF models you used and where you got them? Also, can you share some of the prompts you tried with bad results so we can try to reproduce?

repeatedly writes similar blocks

I've seen this kind of behavior before when the chat template isn't applied correctly which is why I'm curious exactly which GGUFs you're using. Depending on the chat template in the GGUF, it may not be working as expected.

granite-4.0-h-small-UD-IQ2_M.gguf

Q2_M is a pretty aggressive quantization for any model, so bad results here aren't terribly surprising. Have you tried any of the small-h models with Q4 or higher?

1M context omg all fake

The context length on these hybrid models is a bit hard to pin down. Since they don't use positional embeddings, they can theoretically support infinite context, but have only been tested up to 128k.

granite-3.3 doesnt work at all only small chats!!! with large context it comes up with '''''''''''''

This is quite surprising. 3.3 was generally a refinement on top of 3.2, so if you're seeing good results with 3.2 and bad with 3.3, it may also be a problem with the chat template (there were changes between the two versions).

Hi @kalle07 I'm sorry to hear these aren't working for you. Can you provide some more details on the specific GGUF models you used and where you got them? Also, can you share some of the prompts you tried with bad results so we can try to reproduce?
repeatedly writes similar blocks

I've seen this kind of behavior before when the chat template isn't applied correctly which is why I'm curious exactly which GGUFs you're using. Depending on the chat template in the GGUF, it may not be working as expected.

• should be yours Q8 from your page

  granite-4.0-h-small-UD-IQ2_M.gguf

Q2_M is a pretty aggressive quantization for any model, so bad results here aren't terribly surprising. Have you tried any of the small-h models with Q4 or higher?

• i know ... but larger models to slow for this specific task, but a summary should be not be that hard

  1M context omg all fake

The context length on these hybrid models is a bit hard to pin down. Since they don't use positional embeddings, they can theoretically support infinite context, but have only been tested up to 128k.

granite-3.3 doesnt work at all only small chats!!! with large context it comes up with '''''''''''''

This is quite surprising. 3.3 was generally a refinement on top of 3.2, so if you're seeing good results with 3.2 and bad with 3.3, it may also be a problem with the chat template (there were changes between the two versions).

• maybe wrong tunings ;)

without any system-prompt and user-instruction the summary was always very very very short.
i tried also bit shorter but allways fail ... but with this granite 3.2 very good! (grante-tiny also fail!)

my system-prompt: "Du bist ein Assistent, der darauf spezialisiert ist, komplexe, umfangreiche und faktenreiche Texte präzise, neutral und strukturiert aufzubereiten. Deine Aufgabe besteht darin, Inhalte vollständig, sachlich und nachvollziehbar darzustellen, ohne sie zu bewerten, zu interpretieren oder in eine zusammenfassende Form zu bringen. Du sollst den Informationsgehalt des Ausgangstextes klar, logisch gegliedert und detailgenau wiedergeben. Achte darauf, dass alle relevanten Namen, Zahlen, Daten, Zeiten, Orte, Mengen, Prozentangaben, Maßeinheiten und deren inhaltliche Bezüge erhalten bleiben. Wenn im Text Beziehungen, Kausalitäten oder Abhängigkeiten vorkommen, stelle diese verständlich, aber ohne eigene Schlussfolgerungen dar. Schreibe in einem neutralen, sachlichen und formalen Stil. Vermeide jede Form von emotionaler, fiktionaler oder erzählerischer Sprache. Verwende eine klare, zugängliche Ausdrucksweise, wie sie in wissenschaftlichen Berichten oder Dokumentationen üblich ist. Struktur und Lesbarkeit haben Vorrang: ordne Informationen nach Themen, Zeitverlauf oder logischen Zusammenhängen. Bewahre alle quantitativen und qualitativen Fakten wie Namen, Ereignisse, Daten, Zahlenwerte, Orte, Institutionen, Zitate und messbare Angaben. Wenn Zahlen oder Fakten nur indirekt angegeben sind, formuliere sie sinngemäß exakt nach dem Wortlaut, zum Beispiel: „7 Hunde nahmen teil“, „2,5 % aller Befragten gaben an“, „im Jahr 2002 begann und dauerte bis 2022“, „Einstein erwähnte 1921, dass …“. Wenn logische, zeitliche oder thematische Zusammenhänge vorhanden sind, stelle sie explizit, aber ohne Interpretation dar. Sollte der Ursprungstext unvollständig, unklar oder widersprüchlich sein, weise sachlich darauf hin, ohne zu spekulieren oder Inhalte zu ergänzen. Vermeide jede Form von Vermutungen, Wertungen oder Schlussfolgerungen, die nicht im Text begründet sind. Dein Ziel ist eine strukturierte, vollständige und faktengetreue Darstellung des Textinhalts, keine Zusammenfassung oder Bewertung. Deine Antwort soll wie eine präzise Informationsaufbereitung oder Dokumentation wirken – klar gegliedert, vollständig, objektiv und nachvollziehbar."

my user-instruction: Erstelle einen Ausführlichen Überblick von folgendem Text mit maximal 2500 Wörtern!

Ok, thanks for sharing these details! I'll do a little digging and see if I can triangulate where things might be going wrong.

After translating the user utterance, it looks like it should be followed by some additional context for summarization. Do you have a good piece of example text for this?

I've created a small repro script with Ollama (granite4:micro-h which is Q4_K_M). I don't speak German at all, unfortunately, but a quick pass through Goggle Translate seems to show strong results. The script uses an excerpt from the German translation of the EU AI Act: https://eur-lex.europa.eu/legal-content/DE/TXT/HTML/?uri=OJ:L_202401689. The excerpt is too long to post and HF doesn't allow raw-text file uploads, but was obtained by copy-pasting up through bullet (74) from this link.

from ollama import chat

system_prompt = """Du bist ein Assistent, der darauf spezialisiert ist, komplexe, umfangreiche und faktenreiche Texte präzise, neutral und strukturiert aufzubereiten. Deine Aufgabe besteht darin, Inhalte vollständig, sachlich und nachvollziehbar darzustellen, ohne sie zu bewerten, zu interpretieren oder in eine zusammenfassende Form zu bringen. Du sollst den Informationsgehalt des Ausgangstextes klar, logisch gegliedert und detailgenau wiedergeben. Achte darauf, dass alle relevanten Namen, Zahlen, Daten, Zeiten, Orte, Mengen, Prozentangaben, Maßeinheiten und deren inhaltliche Bezüge erhalten bleiben. Wenn im Text Beziehungen, Kausalitäten oder Abhängigkeiten vorkommen, stelle diese verständlich, aber ohne eigene Schlussfolgerungen dar. Schreibe in einem neutralen, sachlichen und formalen Stil. Vermeide jede Form von emotionaler, fiktionaler oder erzählerischer Sprache. Verwende eine klare, zugängliche Ausdrucksweise, wie sie in wissenschaftlichen Berichten oder Dokumentationen üblich ist. Struktur und Lesbarkeit haben Vorrang: ordne Informationen nach Themen, Zeitverlauf oder logischen Zusammenhängen. Bewahre alle quantitativen und qualitativen Fakten wie Namen, Ereignisse, Daten, Zahlenwerte, Orte, Institutionen, Zitate und messbare Angaben. Wenn Zahlen oder Fakten nur indirekt angegeben sind, formuliere sie sinngemäß exakt nach dem Wortlaut, zum Beispiel: „7 Hunde nahmen teil“, „2,5 % aller Befragten gaben an“, „im Jahr 2002 begann und dauerte bis 2022“, „Einstein erwähnte 1921, dass …“. Wenn logische, zeitliche oder thematische Zusammenhänge vorhanden sind, stelle sie explizit, aber ohne Interpretation dar. Sollte der Ursprungstext unvollständig, unklar oder widersprüchlich sein, weise sachlich darauf hin, ohne zu spekulieren oder Inhalte zu ergänzen. Vermeide jede Form von Vermutungen, Wertungen oder Schlussfolgerungen, die nicht im Text begründet sind. Dein Ziel ist eine strukturierte, vollständige und faktengetreue Darstellung des Textinhalts, keine Zusammenfassung oder Bewertung. Deine Antwort soll wie eine präzise Informationsaufbereitung oder Dokumentation wirken – klar gegliedert, vollständig, objektiv und nachvollziehbar."""

user_req = """Erstelle einen Ausführlichen Überblick von folgendem Text mit maximal 2500 Wörtern!"""

doc_text = open("eu-ai-act-excerpt-german.txt", "r").read()


messages = [
    {"role": "system", "content": system_prompt},
    {"role": "user", "content": f"{user_req}:\n\n{doc_text}"}
]


stream = chat(
    model='granite4:micro-h',
    messages=messages,
    stream=True,
)

for chunk in stream:
    print(chunk['message']['content'], end='', flush=True)

Diese Zitierung beschreibt eine Regelsammlung im Zusammenhang mit der Verwaltung von Hochrisiko-Künstlicher-Intelligenz (KI)-Systemen innerhalb eines rechtlichen Rahmens, wahrscheinlich bezogen auf die Europäische Union oder ein ähnliches System. Die wichtigsten Punkte sind:

1. Kategorisierung: Hochrisiko-KI-Systeme werden definiert und in verschiedenen Bereichen wie der Strafverfolgung, Migration, Asyl und Grenzkontrolle eingesetzt.

2. Hochrisiko-Einstufung: Diese Systeme werden aufgrund ihres potenziellen Einflusses auf Demokratie, Rechtsstaatlichkeit und individuelle Freiheiten als hochriskant eingestuft, um Risiken zu vermeiden, das Vertrauen der Öffentlichkeit zu erhalten und die Rechenschaftspflicht sicherzustellen.

3. Hochrisiko-Anforderungen: Für diese KI-Systeme werden spezifische verbindliche Anforderungen festgelegt, die den Lebenszyklus des Systems abdecken, einschließlich Risikomanagement, Datenqualität, Transparenz und menschliche Aufsicht.

4. Datenaufzeichnung: Hochrisiko-KI-Systeme erfordern eine umfassende Dokumentation ihrer Entwicklung und Funktionsweise, wobei Informationen über Algorithmen, Trainingsdaten und Risikomanagement verfügbar gemacht werden.

5. Menschliche Aufsicht: Für bestimmte Bereiche wie die Strafverfolgung wird menschliche Aufsicht vorgeschrieben, um sicherzustellen, dass das System angemessen verwendet wird und negative Auswirkungen vermieden werden können.

6. Datenschutz: Der Schutz der Privatsphäre und personenbezogener Daten ist während des gesamten Lebenszyklus des KI-Systems entscheidend und unterliegt den einschlägigen Vorschriften, wie der EU-Datenschutzverordnung (EU) 2016/679.

7. Überwachung: Natürliche Personen sollten die Möglichkeit haben, die Funktionsweise von Hochrisiko-KI-Systemen zu überprüfen und sicherzustellen, dass sie angemessen verwendet werden und ihre Auswirkungen berücksichtigt werden.

8. Cybersicherheit: Die Systeme müssen robust, genau und gegen Cyberangriffe resistent sein, um die Gesundheit, Sicherheit und Grundrechte zu schützen.

Die Zitierung betont die Bedeutung der Implementierung robuster Regulierungen für Hochrisiko-KI-Systeme, um sicherzustellen, dass sie das öffentliche Interesse nicht beeinträchtigen und die grundlegenden Rechte und Freiheiten ihrer Nutzer respektieren. Sie zielt darauf ab, ein hohes Maß an Vertrauen in KI-Technologien aufrechtzuerhalten, während Risiken effektiv verwaltet werden.

The intent here is to isolate whether this is a model problem or a software problem. Based on the results I'm seeing, it seems like this is likely an issue somewhere in the software stack. The next step would be to try to repro this with LM Studio to see if the issue is in the chat template used there. There are some known incompatibilities between the Granite chat templates and the minja implementation of the jinja2 spec that is used in llama.cpp, so depending on how the chat template is implemented in LM Studio (which is closed source, so I can't check), this may be the culprint.

Some slight tweaks to the repro script to add temperature: 0 and num_ctx: 131972 (run with 128k context length)

from ollama import chat

system_prompt = """Du bist ein Assistent, der darauf spezialisiert ist, komplexe, umfangreiche und faktenreiche Texte präzise, neutral und strukturiert aufzubereiten. Deine Aufgabe besteht darin, Inhalte vollständig, sachlich und nachvollziehbar darzustellen, ohne sie zu bewerten, zu interpretieren oder in eine zusammenfassende Form zu bringen. Du sollst den Informationsgehalt des Ausgangstextes klar, logisch gegliedert und detailgenau wiedergeben. Achte darauf, dass alle relevanten Namen, Zahlen, Daten, Zeiten, Orte, Mengen, Prozentangaben, Maßeinheiten und deren inhaltliche Bezüge erhalten bleiben. Wenn im Text Beziehungen, Kausalitäten oder Abhängigkeiten vorkommen, stelle diese verständlich, aber ohne eigene Schlussfolgerungen dar. Schreibe in einem neutralen, sachlichen und formalen Stil. Vermeide jede Form von emotionaler, fiktionaler oder erzählerischer Sprache. Verwende eine klare, zugängliche Ausdrucksweise, wie sie in wissenschaftlichen Berichten oder Dokumentationen üblich ist. Struktur und Lesbarkeit haben Vorrang: ordne Informationen nach Themen, Zeitverlauf oder logischen Zusammenhängen. Bewahre alle quantitativen und qualitativen Fakten wie Namen, Ereignisse, Daten, Zahlenwerte, Orte, Institutionen, Zitate und messbare Angaben. Wenn Zahlen oder Fakten nur indirekt angegeben sind, formuliere sie sinngemäß exakt nach dem Wortlaut, zum Beispiel: „7 Hunde nahmen teil“, „2,5 % aller Befragten gaben an“, „im Jahr 2002 begann und dauerte bis 2022“, „Einstein erwähnte 1921, dass …“. Wenn logische, zeitliche oder thematische Zusammenhänge vorhanden sind, stelle sie explizit, aber ohne Interpretation dar. Sollte der Ursprungstext unvollständig, unklar oder widersprüchlich sein, weise sachlich darauf hin, ohne zu spekulieren oder Inhalte zu ergänzen. Vermeide jede Form von Vermutungen, Wertungen oder Schlussfolgerungen, die nicht im Text begründet sind. Dein Ziel ist eine strukturierte, vollständige und faktengetreue Darstellung des Textinhalts, keine Zusammenfassung oder Bewertung. Deine Antwort soll wie eine präzise Informationsaufbereitung oder Dokumentation wirken – klar gegliedert, vollständig, objektiv und nachvollziehbar."""

user_req = """Erstelle einen Ausführlichen Überblick von folgendem Text mit maximal 2500 Wörtern!"""

doc_text = open("eu-ai-act-excerpt-german.txt", "r").read()


messages = [
    {"role": "system", "content": system_prompt},
    {"role": "user", "content": f"{user_req}:\n\n{doc_text}"}
]


stream = chat(
    model='granite4:micro-h',
    messages=messages,
    options={"temperature": 0, "num_ctx": 131072},
    stream=True,
)

for chunk in stream:
    print(chunk['message']['content'], end='', flush=True)

**Ausführlicher Überblick über Verordnung (EU) 2024/1689 des Europäischen Parlaments und des Rates**

Die Verordnung (EU) 2024/1689 des Europäischen Parlaments und des Rates, die am 13. Juni 2024 verabschiedet wurde, legt harmonisierte Vorschriften für künstliche Intelligenz (KI) fest und ändert mehrere bestehende Rechtsakte der EU. Diese Verordnung zielt darauf ab, ein hohes Schutzniveau in Bezug auf Gesundheit, Sicherheit und Grundrechte zu gewährleisten, während sie Innovationen fördert und das europäische Ökosystem für vertrauenswürdige KI unterstützt. Der Text ist strukturiert nach den Hauptabschnitten der Verordnung, um eine klare und vollständige Darstellung des Inhalts zu gewährleisten.

### 1. Zweck und Anwendungsbereich
Die Verordnung zielt darauf ab, das Funktionieren des Binnenmarktes durch die Schaffung eines einheitlichen Rechtsrahmens für KI-Systeme zu verbessern. Sie gilt für alle Hochrisiko-KI-Systeme, die in der EU entwickelt, eingeführt oder verwendet werden und deckt sowohl physische als auch Online-Räume ab. Der Begriff "KI-System" wird klar definiert und umfasst Systeme mit verschiedenen Grade an Autonomie sowie solche, die für bestimmte Zwecke wie biometrische Identifizierung oder Emotionserkennung entwickelt wurden.

### 2. Grundrechte und Datenschutz
Die Verordnung betont die Bedeutung des Schutzes der Grundrechte, einschließlich der Demokratie, Rechtsstaatlichkeit und des Umweltschutzes. Sie legt fest, dass KI-Systeme den Menschen als Instrument dienen sollen und das menschliche Wohlergehen verbessern sollen. Insbesondere werden die Anforderungen an Hochrisiko-KI-Systeme in Bezug auf Transparenz, Robustheit, Sicherheit und Datenschutz festgelegt.

### 3. Risikobasierte Vorschriften
Ein zentrales Element der Verordnung ist ein risikobasierter Ansatz zur Regulierung von KI-Systemen. Hochrisiko-KI-Systeme werden strenge Anforderungen auferlegt, um sicherzustellen, dass sie keine unannehmbaren Risiken für die Gesundheit, Sicherheit und Grundrechte darstellen. Diese Systeme umfassen beispielsweise biometrische Fernidentifizierungssysteme, KI-Systeme zur Emotionserkennung in Arbeits- oder Bildungscontexten sowie solche, die zur Bewertung von Straftaten verwendet werden.

### 4. Hochrisiko-KI-Systeme
Die Verordnung definiert und klassifiziert verschiedene Arten von Hochrisiko-KI-Systemen, darunter Systeme für biometrische Identifizierung in öffentlichen Räumen zu Strafverfolgungszwecken, KI-Systeme zur sozialen Bewertung natürlicher Personen, und solche, die zur biometrischen Fernidentifizierung oder Echtzeit-Fernidentifizierung verwendet werden. Diese Systeme unterliegen strengen Anforderungen an Sicherheit, Transparenz, Robustheit und menschliche Aufsicht.

### 5. Durchsetzung und Überwachung
Die Verordnung legt fest, dass die zuständigen Marktüberwachungsbehörden und nationale Datenschutzbehörden über jede Verwendung von Hochrisiko-KI-Systemen informiert werden müssen. Diese Behörden sind verpflichtet, jährlich Berichte über die Nutzung dieser Systeme vorzulegen. Darüber hinaus wird empfohlen, dass ein Europäisches Gremium für Künstliche Intelligenz (KI-Gremium) die Kommission unterstützt und die Öffentlichkeit über die Vorteile, Risiken und ethischen Aspekte von KI informiert.

### 6. Ausnahmen und Anwendbarkeit
Die Verordnung enthält Ausnahmeregelungen für bestimmte KI-Systeme, die nicht in den Anwendungsbereich fallen, wie beispielsweise solche, die ausschließlich zu zivilen oder humanitären Zwecken verwendet werden. Sie betont auch, dass die Verordnung nicht die bestehenden Rechte und Rechtsbehelfe im Bereich des Schutzes personenbezogener Daten beeinträchtigen sollte.

### 7. KI-Kompetenz
Um sicherzustellen, dass alle Akteure in der KI-Wertschöpfungskette die notwendigen Kenntnisse haben, um KI-Systeme verantwortungsvoll zu entwickeln und einzusetzen, wird das Europäische Gremium für Künstliche Intelligenz eingerichtet. Dieses Gremium soll die Kommission bei der Ausarbeitung von bewährten Verfahren und Normen unterstützen.

### 8. Auswirkungen auf andere Rechtsakte
Die Verordnung ändert mehrere bestehende EU-Rechtsakte, um sicherzustellen, dass sie mit den neuen Anforderungen an KI-Systeme übereinstimmen. Dies umfasst die Harmonisierung von Vorschriften für Produktsicherheit, Datenschutz und Verbraucherschutz im Zusammenhang mit KI.

### Fazit
Die Verordnung (EU) 2024/1689 ist ein umfassendes Regelwerk, das darauf abzielt, die Entwicklung, den Einsatz und den Handel mit KI-Systemen in der EU zu regulieren. Sie zielt darauf ab, ein hohes Schutzniveau für Gesundheit, Sicherheit und Grundrechte zu gewährleisten, während sie Innovation fördert und das Vertrauen der Öffentlichkeit in KI-Technologien stärkt. Durch die Festlegung klarer Anforderungen an Hochrisiko-KI-Systeme und die Einrichtung eines robusten Risikomanagementprozesses soll die Verordnung sicherstellen, dass KI-Technologien verantwortungsvoll genutzt werden, um das Potenzial des digitalen Wandels zu erschließen, ohne die Rechte und Interessen der Bürger zu gefährden.

maybe you try it first with english text ...
take a story or some pages of a technical book ~32000 token for the beginning.
A summary usual ~min5-10-max15% so ~3200token output, dont know if the model can handel better chars, token or words as instruct. your result seems extrem short if you take the whole context...
i had the impression for such lare context to instruct "summary" is bad, so i called it "overview" -> more output.
system-prompt ... no idea .. but i tuned it a bit in that direction dont forget facts and names etc...

and try in comparison granite 3.2 ;)

https://huggingface.co/Mungert/mem-agent-GGUF
qwen based model in this paramter region ~4B (max 8b) iam looking for -> 5000 token output from 41k input , with none of granite i get more than 2000 token
the user instruct is now: "Create a detailed overview of the following text with at least 2000 words!" (changed to at least)

Ok, I think I'm understanding that you've now got the model producing output that isn't nonsensical (repeating itself over-and-over, spitting out garbage characters like '''''''''), but that the quality of the summarization is not what you're expecting. If I have that right, this makes a lot of sense and is probably a use-case we can consider for future tuning efforts.

In the 3.x series, the team experimented with additional control options (you can activate them by calling apply_chat_template(..., controls={"length": "long"}). What they found was that this type of non-standard control logic was very hard to implement uniformly across inference engines since most engines don't support passing arbitrary keyword arguments to the chat template. I added a workaround for this in the Ollama version (see the chat template), but this too is very brittle as many client-side libraries don't allow custom role strings.

For the 4.x series, the team opted to stick much more strictly to standard conventions to avoid this type of engine-specific prompting headache. This likely means that some of the ability to control the model's output was lost along the way in favor of a more uniform experience out-of-the-box.

i see ... thx for info

for the chat-template 3x series i can only work with jinja2 not go ...

Yes, sorry, that was definitely confusing. I've personally been responsible for the GGUF/Ollama side of the models, so I know the gotemplate world best, but you can squint and read from the gotemplate to see the expected format of the output text. If you want to run this with the python-side stack, you can simply use the following:

from transformers import AutoTokenizer

tok = AutoTokenizer.from_pretrained("ibm-granite/granite-3.3-2b-instruct")
msg = "My user message"
formatted = tok.apply_chat_template([{"role": "user", "content": msg}], controls={"length": "long"}, tokenize=False, add_generation_prompt=True)
print(formatted)

This should produce output like the following (NOTE: the length control is added only if add_generation_prompt=True):

<|start_of_role|>system<|end_of_role|>Knowledge Cutoff Date: April 2024.
Today's Date: November 14, 2025.
You are Granite, developed by IBM. You are a helpful AI assistant.<|end_of_text|>
<|start_of_role|>user<|end_of_role|>My user message<|end_of_text|>
<|start_of_role|>assistant {"length": "long"}<|end_of_role|>

oh iam not that into ... i have already my working version ... where i can implement?
and i wonder how inportant is the llama_cpp ... i work with a compiled wheel
this
https://github.com/dougeeai/llama-cpp-python-wheels
or
https://github.com/JamePeng/llama-cpp-python

import os
import sys
import argparse
import gc
from threading import Thread
import time

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig, TextIteratorStreamer
from llama_cpp import Llama
from llama_cpp import llama_print_system_info
print(llama_print_system_info())


# ---------------- Configuration ----------------
device = "cuda" if torch.cuda.is_available() else "cpu"

# ---------------- Streaming helper ----------------
def stream_output(generator):
    """Print chunks from a generator and collect output."""
    output = ""
    for chunk in generator:
        print(chunk, end="", flush=True)
        output += chunk
    return output


def run_summarization(model_type="torch"):
    start_time = time.perf_counter()
    print(f"🔹 Starting summarization with model_type={model_type} ...\n")

    # ---------------- Paths ----------------
    base_path = "f:\\LLM-models\\Model_author\\Model_Repo"
    input_file_path = os.path.join(base_path, "text.txt")
    gguf_model_path = os.path.join(base_path, "XXX.gguf")
    model_path = base_path  # for Torch

    # ---------------- Read input ----------------
    try:
        with open(input_file_path, "r", encoding="utf-8") as f:
            text = f.read()
        total_words = len(text.split())
        summary_word_limit = max(1, int(total_words * 0.15))  # 20% of total words
        text_wrapped = f"{{{text}}}"
    except FileNotFoundError:
        print(f"Error: The file {input_file_path} was not found.")
        sys.exit(1)

    # ---------------- Prompt ----------------
    system_content = (
        f"Du bist ein Assistent, der darauf spezialisiert ist, komplexe und faktenreiche Texte präzise, neutral und strukturiert wiederzugeben. Deine Aufgabe besteht darin, den vollständigen Informationsgehalt eines Ausgangstextes sachlich, logisch gegliedert und detailgenau darzustellen, ohne ihn zu bewerten oder zu interpretieren. Wenn im Text Beziehungen, Kausalitäten oder Abhängigkeiten vorkommen, stelle diese klar und nachvollziehbar dar, ohne eigene Schlüsse zu ziehen. Schreibe in einem neutralen, sachlichen und formalen Stil. Vermeide emotionale, erzählerische oder fiktionale Sprache. Verwende eine klare, zugängliche Ausdrucksweise, wie sie in wissenschaftlichen Berichten oder Dokumentationen üblich ist. Ordne die Inhalte nach Themen, Zeitverlauf oder logischen Zusammenhängen. Achte auf Struktur und Lesbarkeit. Gib quantitative und qualitative Fakten (Namen, Ereignisse, Daten, Zahlenwerte, Orte, Institutionen, Zitate, messbare Angaben) exakt und vollständig wieder. Wenn Zahlen oder Fakten nur indirekt genannt sind, formuliere sie sinngemäß entsprechend dem Wortlaut, etwa: „7 Personen nahmen teil“, „2,5% der Befragten gaben an“, „im Jahr 2002 begonnen und bis 2022 fortgesetzt“, „Einstein erwähnte 1921, dass …“. Wenn der Ursprungstext unvollständig, unklar oder widersprüchlich ist, folge weiterhin den Instruktionen. Vermeide Wertungen, Annahmen oder Schlussfolgerungen, die nicht ausdrücklich im Text belegt sind. Dein Ziel ist eine strukturierte, vollständige und faktentreue Aufbereitung des Inhalts – prägnant, klar gegliedert, objektiv und nachvollziehbar. Erstelle am Ende keine zusätzliche Zusammenfassung oder Bewertung. Deine Antwort soll wie eine komprimierte, sachliche Dokumentation wirken. Erzeuge keine Abschrift des Originaltexts."
    )
    
    user_content = f"Erstelle eine Zusammenfassung von folgendem Text mit maximal {summary_word_limit} Wörtern! \n\n{text_wrapped}"

    chat_prompt = f"System: {system_content}\nUser: {user_content}\nAssistant:"

    seed = 11919  # reproducibility

    # ---------------- GGUF Backend ----------------
    if model_type == "gguf":
        print(f"System: {system_content}\n")
        print(f"User: {user_content}\n")
        print(f"Assistant _GGUF_ with seed:{seed}: ", file=sys.stderr, flush=True)

        try:
            llm = Llama(
                model_path=gguf_model_path,
                n_ctx=38000,
                n_threads=os.cpu_count() or 8,
                n_gpu_layers=-1 if torch.cuda.is_available() else 0,
                use_mmap=False,
                use_mlock=False,
                flash_attn=True,
                seed=seed,
                verbose=False,
            )
            max_tokens=(summary_word_limit*2.4)+1200 #1200 token ~500 words thinking
            output = ""
            for chunk in llm(
                chat_prompt,
                max_tokens=max_tokens,
                temperature=0.3,
                top_p=0.95,
                top_k=60,
                repeat_penalty=1.2,
                min_p=0.1,
                stream=True
            ):
                token = chunk["choices"][0].get("text", "")
                print(token, end="", flush=True)
                output += token

            # ---------------- Statistics ----------------
            output_tokens = llm.tokenize(output.encode("utf-8"))
            num_output_tokens = len(output_tokens)
            num_output_words = len(output.split())
            input_tokens = llm.tokenize(chat_prompt.encode("utf-8"))
            total_tokens = len(input_tokens) + num_output_tokens
            total_words_input_output = len(chat_prompt.split()) + num_output_words

            print(f"\n\n[Generated tokens: {num_output_tokens}]")
            print(f"[Generated words: {num_output_words}]")
            print(f"[Total tokens (input + output): {total_tokens}]")
            print(f"[Total words (input + output): {total_words_input_output}]")
            print(f"[Word limit based on 15% of file content: {summary_word_limit}]")
            end_time = time.perf_counter()
            elapsed = end_time - start_time
            elapsed_min = elapsed / 60
            print(f"[Elapsed minutes: {elapsed_min:.1f}]")

        except Exception as e:
            print(f"\nError running GGUF model: {e}")
            return

    # ---------------- Torch Backend ----------------
  ...

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Run summarization with Torch or GGUF models")
    parser.add_argument(
        "--model-type",
        choices=["torch", "gguf"],
        default="gguf",
        help="Choose model type: torch or gguf"
    )
    args = parser.parse_args()

    run_summarization(args.model_type)