Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Haku: Paloitteleminen ja sijoittaminen

Oppitunti 8 / 20 Kehittäjä
Tällä sivulla
  1. Haku: Paloitteleminen ja sijoittaminen
  2. Hakuputki
  3. Paloittelemisstrategian määrittäminen
  4. Merkityskynnys ja sijoittaminen
  5. Hakulaadun optimointi
  6. Hakulaadun mittaaminen
  7. Edistyneet strategiat
  8. Keskeiset asiat

Haku: Paloitteleminen ja sijoittaminen

Tiedostohaku perustuu täydelliseen hakuputkeen: asiakirjasi pilkotaan osiin, muunnetaan vektoreiksi, indeksoidaan ja lopuksi sijoitetaan tärkeysjärjestykseen kyselyn saapuessa. Tämän putken ymmärtäminen antaa sinulle mahdollisuuden optimoida vastausten laatua.

Hakuputki

Kun lataat tiedoston vektorivarastoon, OpenAI suorittaa automaattisesti seuraavat vaiheet:

  1. Jäsennys: Poimii raakatekstin lähdeformaattista
  2. Paloitteleminen: Jakaa tekstin hallittavan kokoisiin segmentteihin
  3. Upotus: Muuntaa jokaisen osan vektoriksi
  4. Indeksointi: Tallentaa vektorit vektorihakemistoon

Kyselyn käsittelyn aikana:

  1. Kyselyn upotus: Kysymys muunnetaan vektoriksi
  2. Vektorihaku: Tunnistaa lähimmät osat
  3. Sijoittaminen: Järjestää tulokset uudelleen merkityksellisyyden perusteella
  4. Syöttö: Syöttää parhaat osat mallin kontekstiin

Paloittelemisstrategian määrittäminen

Paloitteleminen on asetus, joka ohjaa kaikkea muuta, ja kompromissi on suoraviivainen. Lyhyet osat tuottavat tarkkoja hakutuloksia, mutta tarjoavat otteita vailla kontekstia – löydät oikean lauseen, mutta menetät viittauksen kohteen. Pitkät osat säilyttävät kontekstin, mutta hautaavat oleellisen tiedon epäoleellisen tekstin sekaan, mikä heikentää samankaltaisuuspistemäärää.

Yleispätevää arvoa ei ole: oikea asetus riippuu asiakirjasi rakenteesta, aivan kuten alla olevassa taulukossa on tiivistetty.

from openai import OpenAI

client = OpenAI()

# Oletusstrategia: auto
vector_store = client.vector_stores.create(
    name="legal-base",
    chunking_strategy={"type": "auto"}
)

# Mukautettu strategia: pienemmät osat suurempaa tarkkuutta varten
vector_store = client.vector_stores.create(
    name="support-faq",
    chunking_strategy={
        "type": "static",
        "static": {
            "max_chunk_size_tokens": 400,
            "chunk_overlap_tokens": 100
        }
    }
)

Oikean osakoon valinta

Sisältötyyppimax_chunk_sizeoverlapMiksi
Usein kysytyt kysymykset, K&A200-40050Lyhyet, itsenäiset vastaukset
Tekninen dokumentaatio600-800200Kappaleet kontekstin kanssa
Sopimukset, juridiset tekstit800-1200300Pitkät, toisiinsa linkittyvät pykälät
Lähdekoodi400-600100Funktiot ja luokat

Päällekkäisyyden vaikutus

Päällekkäisyys ratkaisee tietyn ongelman: tieto, joka ulottuu osan rajan yli, leikattaisiin muuten kahtia, jolloin kumpikaan puolisko ei vastaisi kyselyyn. Päällekkäisillä osilla varmistat, että jokainen lause esiintyy ehjänä vähintään yhdessä segmentissä. Kustannuksena on redundanssi – 300 tokenin päällekkäisyys 800 tokenin osissa tallentaa lähes 40 % duplikaattitekstiä.

# Alkuperäinen teksti (yksinkertaistettu)
# "Pykälä 5.1 määrää, että toimittajan on toimitettava 30 päivän kuluessa.
#  Viivästystapauksessa sovelletaan 1 %:n sakkoa päivältä.
#  Pykälä 5.2 täsmentää, että sakot on rajoitettu 15 %:iin."

# Ilman päällekkäisyyttä: Pykälä 5.1 ja sakot voivat päätyä eri osiin
# Päällekkäisyyden kanssa: yhteys pykälän ja sakkojen välillä säilyy

Merkityskynnys ja sijoittaminen

Sijoittaminen määrittää, mitkä osat säilytetään. Voit määrittää suodattimen:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Mikä on palautuskäytäntö?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [vector_store.id],
        "max_num_results": 10,
        "ranking_options": {
            "ranker": "auto",
            "score_threshold": 0.5
        }
    }]
)

score_threshold suodattaa pois tulokset, jotka jäävät merkityskynnyksen alapuolelle. Arvo 0,0 palauttaa kaiken, kun taas 1,0 olisi liian rajoittava. Käytännössä 0,3–0,6 tuottaa hyviä tuloksia.

Hakulaadun optimointi

Asiakirjojen valmistelu

Tämä on koko tämän oppitunnin kustannustehokkain vipu ja ainoa, joka ei maksa mitään asetuksissa: hyvin jäsennelty asiakirja indeksoituu hyvin. Käytä selkeitä otsikoita, johdantolausetta jokaiselle osiolle ja vältä taulukoita, jotka on muutettu tekstisotkuksi. Päinvastoin, mikään paloittelemisasetus ei pelasta PDF-tiedostoa, jonka purku tuottaa sotkeutuneet sarakkeet.

# Huono: Skannattu PDF epätarkalla OCR:llä
# -> Epäjohdonmukaiset osat, heikkolaatuiset upotukset

# Hyvä: Jäsennelty asiakirja otsikoilla ja osioilla
# -> Osat kohdistettu loogisiin osioihin

# Malli: Esikäsittely ennen latausta
def prepare_document(raw_text: str) -> str:
    """Puhdistaa ja jäsentelee tekstin ennen indeksointia."""
    # Poista toistuvat ylä- ja alatunnisteet
    lines = raw_text.split("\n")
    lines = [l for l in lines if not is_header_footer(l)]

    # Normalisoi välilyönnit
    text = "\n".join(lines)
    text = re.sub(r"\n{3,}", "\n\n", text)

    return text

Rikastaminen metatiedoilla

Metatiedot mahdollistavat esisuodatuksen ennen vektorihakua, mikä parantaa tarkkuutta:

# Lataus rikkailla metatiedoilla
documents = [
    {"file": "hr-policy-2026.pdf", "department": "hr", "type": "policy", "year": 2026},
    {"file": "supplier-contract-a.pdf", "department": "procurement", "type": "contract", "year": 2026},
    {"file": "it-security-guide.pdf", "department": "it", "type": "guide", "year": 2025},
]

for doc in documents:
    with open(doc["file"], "rb") as f:
        file_obj = client.files.create(file=f, purpose="assistants")

    client.vector_stores.files.create(
        vector_store_id=vector_store.id,
        file_id=file_obj.id,
        attributes={
            "department": doc["department"],
            "document_type": doc["type"],
            "year": doc["year"]
        }
    )

Hakulaadun mittaaminen

Ilman mittaamista mikä tahansa paloittelemisasetus on pelkkää intuitiota. Kahdenkymmenen kysymyksen sarja, jossa tiedät odotetun vastauksen ja sen sisältävän asiakirjan, riittää prosessin objektiiviseen arviointiin: muuta parametria, aja testisarja uudelleen ja vertaa. Tämä on vähäinen vaiva verrattuna tunteihin, jotka käytetään osakoon pohdintaan ilman dataa.

def evaluate_retrieval(test_questions: list[dict], vs_id: str) -> dict:
    """Arvioi hakulaatua testisarjalla.

    Jokainen alkio test_questions-listassa sisältää:
    - question: kysyttävä kysymys
    - expected_answer: vastauksesta odotetut avainsanat tai fraasit
    """
    results = {"total": 0, "relevant": 0, "irrelevant": 0}

    for test in test_questions:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=test["question"],
            tools=[{
                "type": "file_search",
                "vector_store_ids": [vs_id],
                "max_num_results": 5
            }]
        )

        answer = response.output_text.lower()
        found_keywords = sum(
            1 for word in test["expected_answer"]
            if word.lower() in answer
        )

        results["total"] += 1
        if found_keywords >= len(test["expected_answer"]) * 0.5:
            results["relevant"] += 1
        else:
            results["irrelevant"] += 1

    results["relevance_rate"] = results["relevant"] / results["total"]
    return results

Edistyneet strategiat

Useita vektorivarastoja

Kysely useisiin asiakirjakantoihin rinnakkain:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Vertaa henkilöstöpolitiikkaamme lakisääteisiin velvoitteisiin",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [
            vs_internal_policies,
            vs_legal_texts
        ],
        "max_num_results": 15
    }]
)

Ositettujen kyselyiden käyttö

Kysymys, joka sisältää useita pyyntöjä, tuottaa keskimääräisen vektorin, joka ei muistuta mitään niistä, mikä johtaa heikkoihin hakutuloksiin kaikille. Sen jakaminen erillisiin alakysymyksiin tuottaa huomattavasti parempia tuloksia – tämä on sama periaate kuin verkkohaussa: tarkka kysely voittaa tyhjentävän kyselyn.

def decomposed_search(complex_question: str, vs_id: str) -> str:
    """Jakaa monimutkaisen kysymyksen alihakuiksi."""
    # Vaihe 1: Jaa kysymys osiin
    decomposition = client.responses.create(
        model="gpt-5.6-terra",
        input=f"Jaa tämä kysymys 2–3 yksinkertaiseen alakysymykseen: {complex_question}",
    )

    # Vaihe 2: Hae jokaisella alakysymyksellä
    sub_results = []
    for sub_q in decomposition.output_text.split("\n"):
        if sub_q.strip():
            r = client.responses.create(
                model="gpt-5.6-terra",
                input=sub_q.strip(),
                tools=[{"type": "file_search", "vector_store_ids": [vs_id]}]
            )
            sub_results.append(r.output_text)

    # Vaihe 3: Syntetisoi
    synthesis = client.responses.create(
        model="gpt-5.6-terra",
        input=f"Alkuperäinen kysymys: {complex_question}\n\n"
              f"Välitulokset:\n" + "\n---\n".join(sub_results) +
              "\n\nSyntetisoi täydellinen ja johdonmukainen vastaus."
    )
    return synthesis.output_text

Keskeiset asiat

  • static-paloittelu mukautetulla koolla ja päällekkäisyydellä parantaa tarkkuutta
  • Pienet osat usein kysytyille kysymyksille, suuret osat juridisille asiakirjoille
  • score_threshold suodattaa pois epäoleelliset tulokset
  • Puhdista ja jäsentele asiakirjasi ennen indeksointia
  • Arvioi hakulaatua testisarjalla