Er redigiert ein Buch. Ein Buch von meinem Bruder.
Es muss Rechtschreibkorrigiert werden.
Eigentllich sind die Kapitel mit >45kb teilweise zu lang um von einer lokalen KI bearbeitet zu werden.
Aber ich hab CHatGPT gesagt er soll mir ein Skript machen, "was das in Chunks redigiert."
Er nimmt also die Textdateien - die eigentlich zu große sind und verarbeitet eine nach der Anderen,
zerstückelt diese (jeweils am Ende eines Absatzes) und speichert den korrigierten Text dann.
Als Model läuft lokal das GPT-Oss 120b von OpenAI. Bis jetzt sind alle Kapitel 1A.
Wie genau das funktioniert?
Weiss ich nicht das Script hat ChatGPT gemacht. Hat nicht auf Anhieb aber recht bald funktioniert.
Und da es funktioniert hab ich es nicht im Detail untersucht.
Erinnert mich an ein paar andere Bücher die ich mittels KI schon geschrieben habe.
Die es bei AMAZON zu kaufen gibt. Das hier ist eine Beispiel:
Sun Tzu in Holland...
Ich kenne kein einziges Kapitel. Es sollte aber lustig sein.
Ich kann kein Holländisch (ich glaube es ist holländisch aber es könnte auch eine andere Sprache sein).
Es gibt das Buch in mehreren Sprachen (die Meisten davon kann ich nicht).
Wie gesagt. Ich weiss nicht was drin steht.
Ich kann die Sprache nicht in der die Bücher verfasst sind.
Trotzdem konnte ich das machen und die stehen nun zum Verkauf,
Das ist der Punkt. Wir kommen nun in die Zeit wo man Dinge tun kann für die ANDERE die EXPERTISE haben.
Durch KI ist das möglich. Es geht nicht mehr darum mit "Google nachzuschlagen wie etwas geht".
Durch die KI haben wir den Experten für fast alles immer mit dabei.
Das ist die nächste Stufe der Automatisierung.
Man muss nicht mehr Rechnen lernen oder Rechtschreibung.
Es genügt dass man etwas will und im Stande ist zu sagen WAS man will. Die KI macht das dann möglich.
Ein großer Weiser hat vorrausgesagt dass bald 40% der Bevölkerung nur noch auf dem Sofa liegen und TV schauen werden.
Denn die Arbeit macht in der Zukunft wohl die KI. Nur 30% werden sich weiterentwickeln, und 20% werden wohl aus Langeweile kriminell ... irgendwieso wird dieZukunft aussehen die wir heute mitgestalten.
Wir werden immer mehr an die Stelle kommen wo wir auch als "Fachleute" nicht mehr verstehen was da passiert
aber irgendwie halten wir es am Laufen. Genauso wie dieses Beispielscript für den SPR.
Es verwendet KI um Texte zu korrigieren (Rechtschreibung) und diese schön zu formattieren (Absätze, Überschriften).
Dabei erweitert es die Möglichkeiten der lokalen Ki über deren normale Ausgabegröße hinaus in dem es Tricks anwendet.
Als es fertig war fiel mir ein dass ich eigentlich nicht verstanden habe wie es funktioniert.
Das hat mich zu diesem Post inspiriert.
Ich denke dass wir alle das immer öfter sehen werden. Die KI macht Dinge möglich von denen wir nicht mehr verstehen wie sie funktionieren. Die wir nicht mehr kontrollieren können - nur noch an- und ausschalten.
Code: Select all
The robust fix: split the ORIGINAL at Absatz boundaries first, then correct chunk-by-chunk
This removes the whole “stateless continuation / pending prefix” fragility.
Workflow:
Normalize original chapter to CRLF.
Take the first $$MAX bytes.
Find the last CRLFCRLF inside that window using STR.RNInstr.
Cut there (Absatz boundary).
Send only that chunk to the LLM with strict “do not rewrite” rules.
Append the corrected chunk to final output.
Continue with the remaining original text.
No chat memory needed, no prefix matching needed, no risk of “split mid-meaning” (because the split is your Absatz split, not the model’s).
Complete corrected SPR script (strict, chunked, Absatz-safe, uses STR.RNInstr, legal $$xxx variables, logging)
'
'SPR Script-file: Chapter_Fix_Chunked_Stateless
'Purpose: Batch-process chapter .txt files -> corrected + print-ready output
' Chunking is done on ORIGINAL text at Absatz boundaries (CRLFCRLF)
'Author: MINIPC\theog
'Creation date: 12-23-2025
'===========================================================
'#EXE:?path\
'#SPI:ForceWrite
$$PAT=?exeloc\Kapitel
$$TAF=?exeloc\KapitelC1
MKD.$$TAF
FEF.DoIt|$$FIA|$$PAT|*.txt
MBX.Done
ENR.
'===========================================================
:DoIt
GPP.nameonly|$$FIA|$$NAO
VAR.$$TAR=$$TAF\$$NAO.txt
PRT.----------------------------------------
PRT.File: $$NAO
PRT.Source: $$FIA
PRT.Target: $$TAR
CFF.$$FIA|$$RAW
'-----------------------------------------------------------
' Globals / Work vars (3-letter names only)
'-----------------------------------------------------------
$$BLA=[BEG]
$$BLB=[END]
$$BRK=$crlf$$crlf$
$$NL1=$crlf$
$$NL2=$lf$
$$PRO=
$$ANS=
$$OUT=
$$REM=
$$WIN=
$$CHK=
$$FIN=
$$DBG=
VIN.$$MAX=6500
VIN.$$CHP=0
VIN.$$TRY=0
VIN.$$RTM=6
VIN.$$LEN=0
VIN.$$CUT=0
VIN.$$POS=0
VIN.$$PBA=0
VIN.$$PBB=0
VIN.$$LBA=0
VIN.$$LBB=0
'-----------------------------------------------------------
' Normalize ORIGINAL newlines to CRLF
'-----------------------------------------------------------
GSB.NrmRaw
$$REM=$$RAW
$$FIN=
:Loop
LEN.$$REM|$$LEN
IVV.$$LEN=0
PRT.Done. FinalLen follows
LEN.$$FIN|$$LEN
PRT.$$LEN FIN_Len
CTF.$$TAR|$$FIN
RET.
EIF.
VIC.$$CHP
PRT.$$CHP ChunkStart
PRT.$$LEN Rem_Len
'-----------------------------------------------------------
' Decide chunk cut position on ORIGINAL (Absatz boundary)
'-----------------------------------------------------------
GSB.CutOrg
PRT.$$CUT Cut_Len
STR.Left|$$REM|$$CUT|$$CHK
' Remove this piece from $$REM (advance)
LEN.$$REM|$$LEN
CAL.$$POS=$$CUT+1|i
STR.MidTo|$$REM|$$POS|$$LEN|$$REM
'-----------------------------------------------------------
' LLM correct + format this chunk (strict)
'-----------------------------------------------------------
GSB.FixChk
LEN.$$OUT|$$LEN
PRT.$$LEN Out_Len
' Append to final
$$FIN=$$FIN$$OUT
GTO.Loop
RET.
'===========================================================
' Subprograms
'===========================================================
:NrmRaw
' Convert CRLF->LF, remove CR, LF->CRLF
STR.CIReplace|$$RAW|$crlf$|$lf$
STS.CLEAR
STR.CIReplace|$$RAW|$cr$
STS.CLEAR
STR.CIReplace|$$RAW|$lf$|$crlf$
STS.CLEAR
RET.
'-----------------------------------------------------------
:CutOrg
' Determine $$CUT (bytes) so that chunk ends at Absatz boundary (CRLFCRLF)
' Uses STR.RNInstr over a MAX window.
VIN.$$CUT=0
VIN.$$POS=0
LEN.$$REM|$$LEN
' Last chunk fits fully
IVV.$$LEN<=$$MAX
VIN.$$CUT=$$LEN
RET.
EIF.
' Window = first MAX bytes
STR.Left|$$REM|$$MAX|$$WIN
' Find last CRLFCRLF in window
STR.RNInstr|$$WIN|$$BRK|1|0|0|0|1|$$POS
IVV.$$POS!0
' Include the full delimiter (len=4): start pos + 3
CAL.$$CUT=$$POS+3|i
RET.
EIF.
' No Absatz boundary inside window => very long paragraph or missing blank lines.
' Fallback: find last single CRLF in window.
PRT.WARN_No_CRLFCRLF_in_Window_FallbackTo_CRLF
STR.RNInstr|$$WIN|$$NL1|1|0|0|0|1|$$POS
IVV.$$POS!0
' Include CRLF (len=2): start pos + 1
CAL.$$CUT=$$POS+1|i
RET.
EIF.
' Worst-case fallback: hard cut at MAX (should be rare)
PRT.WARN_No_CRLF_in_Window_HardCut
VIN.$$CUT=$$MAX
RET.
'-----------------------------------------------------------
:FixChk
' Ask model to ONLY correct and format, not rewrite.
' Retries hard if markers missing or output empty.
VIN.$$TRY=0
$$OUT=
:Ask
VIC.$$TRY
PRT.$$CHP AskTry
PRT.$$TRY Try_Count
GSB.MkPro
LMS.Set Model|openai/gpt-oss-20b
LMS.Ask|$$PRO|$$ANS
LEN.$$ANS|$$LEN
PRT.$$LEN ANS_Len
STR.Left|$$ANS|160|$$DBG
PRT.$$DBG ANS_Head
GSB.ExtBlk
GSB.NrmOut
LEN.$$OUT|$$LEN
IVV.$$LEN!0
RET.
EIF.
PRT.ERROR_EmptyOrBadExtraction_Retry
IVV.$$TRY<$$RTM
GTO.Ask
EIF.
' Final fallback: use raw chunk unchanged (still normalized already)
PRT.ERROR_FallbackToOriginalChunk
$$OUT=$$CHK
RET.
'-----------------------------------------------------------
:MkPro
$$PRO=
$$PRO+You are a strict German copy-editor and typesetter.$crlf$
$$PRO+TASK: Return the SAME content as INPUT, but corrected and print-ready.$crlf$
$$PRO+$crlf$
$$PRO+Hard rules (must follow):$crlf$
$$PRO+- Do NOT rewrite, do NOT paraphrase, do NOT add, do NOT remove content.$crlf$
$$PRO+- Preserve meaning, facts, order, and paragraph structure.$crlf$
$$PRO+- Only fix spelling/grammar/punctuation, typography, and whitespace.$crlf$
$$PRO+- Keep Absatz breaks exactly (blank line stays blank line).$crlf$
$$PRO+- If this chunk contains the chapter headline as first line and this is PART=1:$crlf$
$$PRO+ Replace ONLY that first line with a better German chapter headline.$crlf$
$$PRO+- If PART>1: Do NOT invent a headline.$crlf$
$$PRO+$crlf$
$$PRO+Return ONLY between markers, nothing else:$crlf$
$$PRO+$$BLA$crlf$
$$PRO+<text>$crlf$
$$PRO+$$BLB$crlf$
$$PRO+$crlf$
$$PRO+PART=$$CHP$crlf$
$$PRO+$crlf$
$$PRO+INPUT:$crlf$
$$PRO+$$BLA$crlf$
$$PRO+$$CHK$crlf$
$$PRO+$$BLB
RET.
'-----------------------------------------------------------
:ExtBlk
' Manual block extract between $$BLA and $$BLB (avoid BLO.* fragility)
$$OUT=
VIN.$$PBA=0
VIN.$$PBB=0
LEN.$$BLA|$$LBA
LEN.$$BLB|$$LBB
IVC.$$ANS=$$BLA
POP.$$PBA
EIF.
IVC.$$ANS=$$BLB
POP.$$PBB
EIF.
PRT.$$PBA BLA_Pos
PRT.$$PBB BLB_Pos
IVV.$$PBA=0
RET.
EIF.
IVV.$$PBB=0
RET.
EIF.
IVV.$$PBB<=$$PBA
RET.
EIF.
CAL.$$POS=$$PBA+$$LBA|i
CAL.$$CUT=$$PBB-1|i
STR.MidTo|$$ANS|$$POS|$$CUT|$$OUT
RET.
'-----------------------------------------------------------
:NrmOut
' Normalize output newlines to CRLF (same as raw)
STR.CIReplace|$$OUT|$crlf$|$lf$
STS.CLEAR
STR.CIReplace|$$OUT|$cr$
STS.CLEAR
STR.CIReplace|$$OUT|$lf$|$crlf$
STS.CLEAR
RET.
Why this version fixes your log symptoms
No $$PEN / prefix mechanism at all → cannot fall into “ADD=0, REM=OUT” loops.
Chunk split is done on original using STR.RNInstr → always Absatz-aligned by construction.
IVV comparisons use ! where needed (I avoided <> entirely).
Extraction uses a manual marker parser (no dependence on BLO.Block Get First behavior).
Prompt is content-preserving (no rewriting/hallucination), only correction + typography.
Strict retries are present; after $$RTM failures it falls back to original chunk (and logs it).