Transkribera och korrigera med AI

import os, warnings
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor, pipeline
import torch

warnings.filterwarnings("ignore", message=".*deprecated.*")

# --- Inställningar ---
MODEL    = "KBLab/kb-whisper-large"
DEVICE   = "cuda:0" if torch.cuda.is_available() else "cpu"
DTYPE    = torch.float16 if torch.cuda.is_available() else torch.float32
DIR      = "chunks"
OUTFILE  = "transcript_with_timestamps.txt"
CHUNK_DURATION_S = 30

# Ladda modellen och processorn
print(f"Laddar modell {MODEL} till {DEVICE}...")
model = AutoModelForSpeechSeq2Seq.from_pretrained(MODEL, torch_dtype=DTYPE, use_safetensors=True).to(DEVICE)
processor = AutoProcessor.from_pretrained(MODEL)
asr_pipeline = pipeline(
    "automatic-speech-recognition",
    model=model,
    tokenizer=processor.tokenizer,
    feature_extractor=processor.feature_extractor,
    device=DEVICE,
    torch_dtype=DTYPE
)

# Hjälpfunktion för att formatera tid
def format_time(seconds):
    h, r = divmod(seconds, 3600)
    m, s = divmod(r, 60)
    return f"{int(h):02d}:{int(m):02d}:{int(s):02d}"

# Hämta och sortera ljudfilerna
files = sorted([f for f in os.listdir(DIR) if f.endswith(".wav")])

# Öppna en fil att skriva resultatet till
with open(OUTFILE, "w", encoding="utf-8") as out:
    for filename in files:
        chunk_index = int(filename.split("_")[1].split(".")[0])
        start_time = chunk_index * CHUNK_DURATION_S
        end_time = start_time + CHUNK_DURATION_S
        
        filepath = os.path.join(DIR, filename)
        print(f"Transkriberar {filename}...")
        
        result = asr_pipeline(filepath, generate_kwargs={"language": "sv"})
        text = result["text"].strip()
        
        out.write(f"[{format_time(start_time)} - {format_time(end_time)}]\n{text}\n\n")

print(f"Transkribering klar! Resultat sparat i: {OUTFILE}")

import re
from transformers import pipeline

# --- Inställningar ---
INPUT_FILE  = "transcript_with_timestamps.txt"
OUTPUT_FILE = "transcript_punctuated.txt"
MODEL = "sdadas/byt5-text-correction"
BATCH_SIZE = 8 # Bearbeta 8 textblock åt gången för effektivitet

# Funktion för att säkerställa stor bokstav efter punkt.
def capitalize_sentences(text):
    parts = re.split(r'([.?!]\s*)', text)
    return "".join(p.capitalize() for p in parts)

print(f"Laddar punktueringsmodell {MODEL}...")
punctuation_pipeline = pipeline(
    "text2text-generation",
    model=MODEL,
    tokenizer=MODEL,
    device=0, # Använd första GPU:n
    batch_size=BATCH_SIZE
)

# Läs in den råa texten
with open(INPUT_FILE, 'r', encoding='utf-8') as f:
    lines = f.read().splitlines()

# Separera tidsstämplar från text som ska bearbetas
timestamps, texts_to_process = [], []
for line in lines:
    if line.startswith("[") or not line.strip():
        timestamps.append(line)
    else:
        timestamps.append(None) # Markör för text
        texts_to_process.append(line)

print(f"Korrigerar {len(texts_to_process)} textsegment...")
corrected_texts = punctuation_pipeline(texts_to_process)

# Sätt ihop den slutgiltiga texten
output_lines = []
text_index = 0
for ts in timestamps:
    if ts is not None:
        output_lines.append(ts)
    else:
        # Hämta korrigerad text och applicera versalisering
        corrected_text = corrected_texts[text_index]['generated_text'].strip()
        final_text = capitalize_sentences(corrected_text)
        output_lines.append(final_text)
        text_index += 1

with open(OUTPUT_FILE, 'w', encoding='utf-8') as f:
    f.write("\n".join(output_lines))

print(f"Punktuering klar! Resultat sparat i: {OUTPUT_FILE}")