Text Generation Applications › Code Implementation

# For tokenization and quality measurement

# Download NLTK data if needed
import nltk

nltk.download("punkt", quiet=True)
nltk.download("punkt_tab", quiet=True)

# Representative product description generation examples
# These represent the range of outputs from instruction-tuned models

product_examples = {
    "keyboard": {
        "attributes": {
            "name": "KeyPro X1 Wireless Keyboard",
            "connectivity": "Bluetooth 5.0",
            "battery_life": "6 months",
            "layout": "Tenkeyless",
            "switches": "Silent tactile",
            "weight": "380g",
            "compatibility": "Windows, macOS, Linux",
        },
        "generated_outputs": [
            "The KeyPro X1 Wireless Keyboard delivers a premium typing experience for remote workers. Featuring Bluetooth 5.0 connectivity and silent tactile switches, it keeps your workspace quiet without sacrificing feedback. The 6-month battery life means you can focus on work rather than charging cables. At 380g, this tenkeyless layout keyboard is light enough to carry between locations while remaining solid enough to anchor your workstation. Compatible with Windows, macOS, and Linux, it fits naturally into any workflow.",
            "Work from anywhere without the noise. The KeyPro X1 combines Bluetooth 5.0 reliability with silent tactile switches to deliver a distraction-free typing experience. Six months of battery life, tenkeyless portability, and universal compatibility across Windows, macOS, and Linux make this keyboard the obvious choice for the modern remote worker.",
            "Introducing the KeyPro X1 Wireless Keyboard: engineered for professionals who demand silence, portability, and lasting power. With Bluetooth 5.0 multi-device connectivity, silent tactile switches, and a remarkable 6-month battery life, the X1 redefines what a wireless keyboard can be. Its lightweight tenkeyless form factor fits every desk, every bag, and every operating system.",
        ],
    }
}

# Quality measurement functions
def count_words(text: str) -> int:
    """Count words in text using simple whitespace tokenization."""
    return len(text.split())


def count_sentences(text: str) -> int:
    """Count sentences using NLTK sentence tokenizer."""
    sentences = sent_tokenize(text)
    return len(sentences)


def avg_sentence_length(text: str) -> float:
    """Average words per sentence."""
    sentences = sent_tokenize(text)
    if not sentences:
        return 0.0
    word_counts = [len(s.split()) for s in sentences]
    return sum(word_counts) / len(word_counts)


def attribute_coverage(text: str, attributes: dict) -> float:
    """Fraction of attribute values mentioned in the text."""
    text_lower = text.lower()
    mentioned = 0
    total = 0
    for key, value in attributes.items():
        if key == "name":
            continue  # Skip product name
        total += 1
        # Check if the value or key term appears
        val_str = str(value).lower()
        key_words = key.replace("_", " ").lower()
        if val_str in text_lower or key_words in text_lower:
            mentioned += 1
    return mentioned / total if total > 0 else 0.0


def compute_quality_metrics(text: str, attributes: dict) -> dict:
    """Compute quality metrics for a generated product description."""
    return {
        "word_count": count_words(text),
        "sentence_count": count_sentences(text),
        "avg_sentence_length": round(avg_sentence_length(text), 1),
        "attribute_coverage": round(attribute_coverage(text, attributes), 2),
    }

def type_token_ratio(text: str) -> float:
    """
    Type-Token Ratio (TTR): unique words / total words.
    Higher values indicate greater lexical diversity.
    Values above 0.7 are generally considered diverse.
    """
    tokens = text.lower().split()
    if not tokens:
        return 0.0
    types = set(tokens)
    return len(types) / len(tokens)


def moving_average_ttr(text: str, window: int = 50) -> float:
    """
    Moving-Average TTR (MATTR): average TTR over sliding windows.
    Less sensitive to document length than raw TTR.
    """
    tokens = text.lower().split()
    if len(tokens) < window:
        return type_token_ratio(text)
    ttrs = []
    for i in range(len(tokens) - window + 1):
        window_tokens = tokens[i : i + window]
        ttrs.append(len(set(window_tokens)) / window)
    return sum(ttrs) / len(ttrs)


def top_n_repeated_words(text: str, n: int = 5) -> List[tuple]:
    """Find the most frequently repeated content words."""
    stopwords = {
        "the",
        "a",
        "an",
        "is",
        "it",
        "in",
        "on",
        "for",
        "of",
        "and",
        "to",
        "with",
        "you",
        "your",
        "its",
        "this",
        "that",
        "from",
        "are",
        "be",
        "as",
        "at",
        "or",
        "by",
        "can",
        "will",
        "not",
    }
    tokens = text.lower().split()
    # Remove punctuation and stopwords
    clean_tokens = [re.sub(r"[^a-z]", "", t) for t in tokens]
    content_words = [t for t in clean_tokens if t and t not in stopwords]
    counts = Counter(content_words)
    return counts.most_common(n)

@dataclass
class GenerationConstraints:
    """Specification of constraints for a generation task."""

    min_words: Optional[int] = None
    max_words: Optional[int] = None
    required_phrases: List[str] = None
    forbidden_phrases: List[str] = None
    min_sentences: Optional[int] = None
    max_sentences: Optional[int] = None

    def __post_init__(self):
        if self.required_phrases is None:
            self.required_phrases = []
        if self.forbidden_phrases is None:
            self.forbidden_phrases = []


def check_constraints(text: str, constraints: GenerationConstraints) -> dict:
    """
    Verify that a generated text satisfies all constraints.
    Returns a dict of constraint name -> (passed, details).
    """
    results = {}
    word_count = count_words(text)
    sentence_count = count_sentences(text)
    text_lower = text.lower()

    if constraints.min_words is not None:
        passed = word_count >= constraints.min_words
        results["min_words"] = (
            passed,
            f"got {word_count}, need >= {constraints.min_words}",
        )

    if constraints.max_words is not None:
        passed = word_count <= constraints.max_words
        results["max_words"] = (
            passed,
            f"got {word_count}, need <= {constraints.max_words}",
        )

    if constraints.min_sentences is not None:
        passed = sentence_count >= constraints.min_sentences
        results["min_sentences"] = (passed, f"got {sentence_count}")

    if constraints.max_sentences is not None:
        passed = sentence_count <= constraints.max_sentences
        results["max_sentences"] = (passed, f"got {sentence_count}")

    for phrase in constraints.required_phrases:
        present = phrase.lower() in text_lower
        results[f"required:'{phrase}'"] = (
            present,
            "found" if present else "MISSING",
        )

    for phrase in constraints.forbidden_phrases:
        absent = phrase.lower() not in text_lower
        results[f"forbidden:'{phrase}'"] = (
            absent,
            "absent" if absent else "PRESENT (violation)",
        )

    return results


def constraint_pass_rate(results: dict) -> float:
    """Fraction of constraints that passed."""
    passed = sum(1 for v, _ in results.values() if v)
    return passed / len(results) if results else 1.0

# Define constraints for the product description task
constraints = GenerationConstraints(
    min_words=50,
    max_words=120,
    required_phrases=["bluetooth", "battery"],
    forbidden_phrases=["inferior", "cheap"],
    max_sentences=6,
)

def score_output(
    text: str, attributes: dict, constraints: GenerationConstraints
) -> dict:
    """
    Composite quality score for a generated text.
    Components: constraint compliance, attribute coverage, lexical diversity.
    """
    constraint_results = check_constraints(text, constraints)
    compliance = constraint_pass_rate(constraint_results)
    coverage = attribute_coverage(text, attributes)
    diversity = type_token_ratio(text)

    # Weighted composite: compliance is most critical
    composite = 0.50 * compliance + 0.30 * coverage + 0.20 * diversity

    return {
        "compliance": round(compliance, 3),
        "coverage": round(coverage, 3),
        "diversity": round(diversity, 3),
        "composite": round(composite, 3),
    }


def select_best_output(
    outputs: List[str], attributes: dict, constraints: GenerationConstraints
) -> tuple:
    """Score all outputs and return (best_output, best_score, all_scores)."""
    scores = [score_output(o, attributes, constraints) for o in outputs]
    best_idx = max(range(len(scores)), key=lambda i: scores[i]["composite"])
    return outputs[best_idx], scores[best_idx], scores

def build_product_description_prompt(
    attributes: dict,
    constraints: GenerationConstraints,
    style: str = "professional",
) -> str:
    """
    Build a structured prompt for product description generation.

    Good prompts have four components:
    1. Role/persona specification
    2. Task description with explicit output format
    3. Constraints stated precisely
    4. Input data
    """
    # Format attributes as a structured list
    attr_lines = []
    for key, value in attributes.items():
        label = key.replace("_", " ").title()
        attr_lines.append(f"  - {label}: {value}")
    attrs_str = "\n".join(attr_lines)

    # Translate constraints to natural language
    constraint_parts = []
    if constraints.min_words and constraints.max_words:
        constraint_parts.append(
            f"- Length: {constraints.min_words} to {constraints.max_words} words"
        )
    if constraints.required_phrases:
        constraint_parts.append(
            f"- Must mention: {', '.join(constraints.required_phrases)}"
        )
    if constraints.forbidden_phrases:
        constraint_parts.append(
            f"- Never use: {', '.join(constraints.forbidden_phrases)}"
        )
    if constraints.max_sentences:
        constraint_parts.append(
            f"- Maximum {constraints.max_sentences} sentences"
        )
    constraints_str = "\n".join(constraint_parts)

    prompt = f"""You are an expert copywriter specializing in {style} product descriptions.

Write a product description for an e-commerce listing based on the attributes below.

Constraints:
{constraints_str}

Product attributes:
{attrs_str}

Write only the description. Do not include a title or headings."""

    return prompt


def analyze_prompt_structure(prompt: str) -> dict:
    """Count structural components in a prompt."""
    lines = prompt.strip().split("\n")
    return {
        "total_lines": len(lines),
        "word_count": count_words(prompt),
        "has_role": any("you are" in l.lower() for l in lines),
        "has_task": any("write" in l.lower() for l in lines),
        "has_constraints": "constraints" in prompt.lower(),
        "has_data": "attributes" in prompt.lower(),
        "has_output_format": "only the" in prompt.lower(),
    }