Implement text analysis solutions practice questions

Custom NER trains an extractor for your own entity categories from labelled examples.

The insurer needs its own categories, has labelled data, needs precise offsets and wants a retrainable model. Custom NER is built for exactly that. Prebuilt NER lacks the categories, key phrase extraction has no categories or training, and a prompted language model can name the clauses but doesn't give dependable span offsets or learn from the labelled set.

1. Spot the custom categories: the clause types are the insurer's own.
2. Note the labelled data and the offset requirement.
3. Choose the feature that trains on labelled spans and returns offsets.
4. Reject the preconfigured features and the untrained prompt.

Exam tip: Own categories + labelled data + exact spans = custom NER.

Strict structured outputs need a way to express 'not present' for fields that are sometimes missing.

Under strict mode all properties are required, so a field that is sometimes absent is declared as a union such as ["string", "null"], and the prompt says to return null when the document doesn't state it. Removing the field from required breaks strict-mode rules, JSON mode drops schema enforcement, and a pattern only shapes the fabricated value.

1. Diagnose the symptom: the schema forces a string, so the model invents one.
2. Recall that strict mode requires every property in required.
3. Express optional values as a null union and instruct the model to use null.
4. Reject changes that weaken the schema or only constrain format.

Exam tip: In strict schemas, optional means a null union plus an instruction to use null, never a dropped required entry.

Structured outputs can constrain a field to a fixed set of values.

When a downstream system accepts only fixed values, make the model's output schema enforce them: an enum field with strict structured outputs. Prompt instructions and temperature reduce variation but don't guarantee valid labels, and key phrases aren't topic labels at all.

1. Identify the failure: labels outside the allowed set.
2. Ask which control guarantees the value set, not just encourages it.
3. Choose an enum in a strict schema.

Exam tip: Fixed taxonomies belong in an enum in the schema, not only in the prompt.

Content larger than the context window is summarized in stages.

When a document can't fit in one request, split it on its natural boundaries, summarize each part, then summarize or merge the partial summaries (a map-reduce pattern). Each partial summary keeps its section reference for traceability. Truncation and partial input both drop content, and the output token limit doesn't affect how much input fits.

1. Note two requirements: cover every section and trace points to sections.
2. Recognize the hard limit: input exceeds the context window.
3. Separate input limits from output limits and from truncation behaviour.
4. Choose staged summarization by section, then a combining pass.

Exam tip: Too long for the window: summarize parts, then summarize the summaries.

Domain summaries are customized with instructions for structure and a schema that forces source references.

Compliance summarization needs a fixed structure and verifiable grounding. A system message sets the headings and the citation rule, and a strict schema with a per-finding source field makes the citation impossible to skip. Few-shot examples show the layout but enforce nothing, JSON mode returns valid JSON without enforcing the fields, and web search brings in content from outside the report.

1. Separate the requirements: fixed headings, per-finding citations, nothing from outside.
2. Use instructions for the headings and citation rule.
3. Use a schema field so every finding carries its source paragraph.
4. Reject options that only suggest a format or that bring in outside content.

Exam tip: For compliance summaries, instruct the structure and make source citations a required field in a strict schema.

Fine-tuning moves repeated format and style guidance from the prompt into the model.

Few-shot prompting works but costs tokens on every call. When a large set of approved input and output pairs exists and the knowledge is already in the request, supervised fine-tuning is the standard way to bake in format, tone and style so the prompt can shrink. Retrieval and routing keep sending examples, and batch processing lowers price at the cost of latency. Prompt caching can discount a repeated prefix, but it reduces rather than removes the per-call example tokens; fine-tuning removes them.

1. Find the root cost: thousands of example tokens on every request.
2. Note that knowledge isn't missing; the contract is supplied each time.
3. Recall that fine-tuning targets format and style and uses input and output pairs.
4. Reject options that still send the examples with every call or that trade away latency.

Exam tip: Style or format that needs long examples every call is a fine-tuning candidate; missing knowledge is a retrieval candidate.