Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Ullmhaigh na Sonraí

Ceacht 10 as 18 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Braitheann Cáilíocht RAG ar do Chuid Sonraí
  2. Na Sonraí a Fháil
  3. Na Sonraí a Ghlanadh
  4. Straitéisí Blúireachta
  5. Píblíne Ullmhúcháin Iomlán
  6. Príomhphointí

Braitheann Cáilíocht RAG ar do Chuid Sonraí

Níl píblíne RAG ach chomh maith leis na sonraí a innéacsann sí. Is féidir leat an leid fhoirfe a chruthú agus an tsamhail ghiniúna is fearr a roghnú, ach má ghearrann an blúire a fhaightear sainmhíniú ina dhá leath nó má tharraingíonn sé buntásc athfhillteach isteach in ionad téacs úsáideach, beidh do fhreagairt faoi mhíbhuntáiste. Tarlaíonn an t-ullmhúchán i dtrí chéim: faigh na sonraí san áit a bhfuil siad, bain aon rud gan bhrí, agus roinn iad ina mblúirí atá optamaithe don innéacsú.

Na Sonraí a Fháil

Is annamh a bhíonn corpais sa saol mór aonchineálach. De ghnáth, beidh doiciméadú Markdown i stór, cúpla leathanach ó shuíomh gréasáin poiblí, agus roinnt PDFanna rialála agat. Teastaíonn lódóir ar leith ó gach foinse, ach caithfidh siad go léir an struchtúr céanna a tháirgeadh—ábhar, foinse, agus cineál—ionas go mbeidh an chuid eile den phíblíne neamhspleách ar thionscnamh an téacs.

I gcás comhaid téacs, tá siúlóid athfhillteach treorach leordhóthanach, agus coscaíonn scagadh de réir foirceannadh luchtú comhaid dhénártha de thaisme.

import os

def load_text_files(directory, extensions=(".txt", ".md", ".rst")):
    """Load all text files from a directory."""
    documents = []
    for root, dirs, files in os.walk(directory):
        for f in files:
            if any(f.endswith(ext) for ext in extensions):
                filepath = os.path.join(root, f)
                with open(filepath, "r", encoding="utf-8") as fh:
                    content = fh.read()
                documents.append({
                    "content": content,
                    "source": filepath,
                    "type": "text",
                })
    return documents

docs = load_text_files("./data/")
print(f"{len(docs)} documents loaded")

Tagann leathanaigh ghréasáin isteach trí HTTP, ach is HTML a fhaigheann tú. Bainíonn an eastóscadh thíos clibeanna ag baint úsáide as slonnrialta agus laghdaíonn sé spásanna iolracha. Tá sé seo leordhóthanach do phrótaitíopa, ach cuimhníonn an nóta go ndéanfaidh BeautifulSoup i bhfad níos fearr le táblaí agus liostanna neadaithe i dtimpeallacht táirgeachta.

import requests

def fetch_web_page(url):
    """Fetch the text content of a web page."""
    response = requests.get(url)
    response.raise_for_status()

    # Basic text extraction (use BeautifulSoup for production)
    text = response.text
    # Remove HTML tags
    import re
    text = re.sub(r'<[^>]+>', ' ', text)
    text = re.sub(r'\s+', ' ', text).strip()

    return {
        "content": text,
        "source": url,
        "type": "web",
    }

# Example
page = fetch_web_page("https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt")
print(f"Content: {len(page['content'])} characters")

Tuilleann PDFanna cóireáil speisialta. In ionad an doiciméad iomlán a chumasc, coinnigh iontráil amháin in aghaidh an leathanaigh agus ionchódaigh uimhir an leathanaigh sa fhoinse mar file.pdf#page=12. Nuair a luaíonn do chúntóir an pasáiste seo, beidh a fhios ag an úsáideoir go díreach cá háit le fíorú a dhéanamh air.

# pip install PyPDF2
from PyPDF2 import PdfReader

def load_pdf(filepath):
    """Extract text from a PDF."""
    reader = PdfReader(filepath)
    pages = []
    for i, page in enumerate(reader.pages):
        text = page.extract_text()
        if text.strip():
            pages.append({
                "content": text,
                "source": f"{filepath}#page={i+1}",
                "type": "pdf",
                "page": i + 1,
            })
    return pages

Na Sonraí a Ghlanadh

Tá glanadh ríthábhachtach do cháilíocht an aisghabhála toisc go n-itheann gach carachtar eachtrannach spás sa bhlúire agus go gcuireann sé isteach ar an veicteoir a eascraíonn as. Déanann an fheidhm seo a leanas ceithre chóireáil a shlabhrú: bainíonn sí carachtair rialaithe atá fágtha ó thiontuithe formáide, normalaíonn sí seichimh de línte nua agus spásanna, scriosann sí marcóirí leathanaithe atá tipiciúil do PDFanna, agus cuireann sí ionadaitheoir simplí in ionad URLanna gan deireadh ionas nach n-itheann siad blúire iomlán.

import re

def clean_text(text):
    """Clean text for RAG indexing."""
    # Remove control characters
    text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)

    # Normalize spaces and newlines
    text = re.sub(r'\n{3,}', '\n\n', text)
    text = re.sub(r' {2,}', ' ', text)

    # Remove repetitive headers/footers (PDF)
    text = re.sub(r'Page \d+ of \d+', '', text)

    # Remove very long URLs
    text = re.sub(r'https?://\S{100,}', '[URL]', text)

    return text.strip()

# Apply cleaning
for doc in docs:
    doc["content"] = clean_text(doc["content"])

Straitéisí Blúireachta

Is é an blúireacht an chéim is tábhachtaí san ullmhúchán: bíonn tionchar díreach ag méid agus modh na blúireachta ar cháilíocht an aisghabhála. Tá trí chur chuige ann, ó mheicniúil go dtí struchtúr-chomhfhiosach.

Bogann blúireacht de mhéid seasta tríd an téacs i slisní rialta. Déanann sí neamhaird ar bhrí go hiomlán, rud a fhágann go bhfuil sí infheidhme ar aon fhoinse, ach go minic gearrann sí abairtí ina dhá leath. Ceartaíonn forluí an locht seo go páirteach: le overlap=200, déantar deireadh gach blúire a athrá ag tús an chinn eile, ag cinntiú go bhfanann smaoineamh scoilte slán in ceann amháin ar a laghad den dá phíosa.

def chunk_fixed_size(text, chunk_size=2048, overlap=200):
    """Fixed-size chunking with overlap."""
    chunks = []
    start = 0
    while start < len(text):
        end = min(start + chunk_size, len(text))
        chunk = text[start:end]
        if chunk.strip():
            chunks.append(chunk.strip())
        start += chunk_size - overlap
    return chunks

Braitheann blúireacht bunaithe ar mhíreanna, a mholtar do dhoiciméadú, ar theorainneacha nádúrtha an téacs ina ionad sin. Carnann sí míreanna fad is a fhanann siad faoi max_size, ansin osclaíonn sí blúire nua. Coscaíonn an tairseach min_size innéacsú ceanntáisc díthreabhaithe nó líne aonair, rud a chruthódh veicteoir gan ábhar inúsáidte.

def chunk_by_paragraphs(text, max_size=1500, min_size=100):
    """Intelligent paragraph-based chunking."""
    paragraphs = text.split("\n\n")
    chunks = []
    current = ""

    for para in paragraphs:
        para = para.strip()
        if not para:
            continue

        if len(current) + len(para) + 2 <= max_size:
            current = current + "\n\n" + para if current else para
        else:
            if len(current) >= min_size:
                chunks.append(current)
            current = para

    if current and len(current) >= min_size:
        chunks.append(current)

    return chunks

Baineann blúireacht rannán Markdown leas as an eolas a thug an t-údar cheana féin: a gceanntáisc. Déantar blúire neamhspleách de gach rannán, ag ráthú go n-aisghabhfaidh ceist faoi “fíordheimhniú” an rannán iomlán seachas blúire. Téann rannáin atá ró-fhada ar ais chuig blúireacht mhíreanna, ag cinntiú nach sáraíonn aon bhlúire an teorainn.

def chunk_by_markdown_sections(text, max_size=2000):
    """Chunking by Markdown headings (## and ###)."""
    sections = re.split(r'\n(?=##\s)', text)
    chunks = []

    for section in sections:
        section = section.strip()
        if not section:
            continue
        if len(section) <= max_size:
            chunks.append(section)
        else:
            # Sub-chunk overly long sections
            sub_chunks = chunk_by_paragraphs(section, max_size=max_size)
            chunks.extend(sub_chunks)

    return chunks

Píblíne Ullmhúcháin Iomlán

Ar deireadh, slabhraigh na trí oibríocht le chéile agus roghnaigh an straitéis blúireachta bunaithe ar chineál an chomhaid: téann comhaid .md trí rannáin, agus téann gach rud eile trí mhíreanna. Iompraíonn gach blúire a chuid meiteashonraí ansin—foinse, suíomh sa doiciméad, agus líon iomlán na mblúirí ón doiciméad sin. Gan é seo, ní bheidh tú in ann foinse a chur le freagairt. Taispeánann an dá líne dheireanacha an ráta leathnaithe agus an meánmhéid: má thiteann an meán seo i bhfad faoi do chunk_size, tá an doiciméad níos ilroinnte ná mar a bhíothas ag súil leis, agus ní mór duit do straitéis blúireachta a athbhreithniú.

def prepare_documents(raw_docs, chunk_size=1500, overlap=200):
    """Complete pipeline: clean, chunk, enrich with metadata."""
    all_chunks = []

    for doc in raw_docs:
        # 1. Clean
        clean = clean_text(doc["content"])

        # 2. Chunk based on type
        if doc.get("source", "").endswith(".md"):
            chunks = chunk_by_markdown_sections(clean, max_size=chunk_size)
        else:
            chunks = chunk_by_paragraphs(clean, max_size=chunk_size)

        # 3. Enrich with metadata
        for i, chunk in enumerate(chunks):
            all_chunks.append({
                "text": chunk,
                "source": doc["source"],
                "chunk_index": i,
                "total_chunks": len(chunks),
            })

    return all_chunks

# Execution
chunks = prepare_documents(docs)
print(f"{len(docs)} documents -> {len(chunks)} chunks")
print(f"Average size: {sum(len(c['text']) for c in chunks) / len(chunks):.0f} characters")

Príomhphointí

  • Braitheann cáilíocht RAG go díreach ar cháilíocht na sonraí agus ar an straitéis blúireachta
  • Glan na sonraí sula ndéantar iad a innéacsú (bain carachtair eachtrannacha, URLanna fada, dúbailtí)
  • Coimeádann blúireacht mhíreanna nó rannán Markdown comhleanúnachas shéimeantach
  • Coscaíonn forluí 10–15% idir blúirí scoilt smaoineamh
  • Coinnigh meiteashonraí (foinse, leathanach, suíomh) chun inrianaitheacht na freagartha a chinntiú