LLM Licensing, IP & Privacy

1. Model License Taxonomy

def check_license_compatibility(model_license: str, use_case: dict) -> dict:
    """Check if a model license permits the intended use case."""
    rules = {
        "apache-2.0": {"commercial": True, "modification": True, "distribution": True},
        "llama-community": {"commercial": True, "modification": True,
                            "distribution": True, "mau_limit": 700_000_000},
        "cc-by-nc-4.0": {"commercial": False, "modification": True, "distribution": True},
    }

    license_rules = rules.get(model_license, {})
    issues = []

    if use_case.get("commercial") and not license_rules.get("commercial"):
        issues.append("Commercial use not permitted")
    if use_case.get("mau", 0) > license_rules.get("mau_limit", float("inf")):
        issues.append(f"MAU exceeds license limit of {license_rules['mau_limit']:,}")

    return {"compatible": len(issues) == 0, "issues": issues}

result = check_license_compatibility(
    "llama-community",
    {"commercial": True, "mau": 500_000}
)
print(result)

2. Differential Privacy for LLM Training

import torch
import numpy as np

def dp_sgd_step(gradients: list, clip_norm: float, noise_scale: float, lr: float):
    """Simulate a DP-SGD gradient step with clipping and noise."""
    clipped = []
    for grad in gradients:
        grad_norm = np.linalg.norm(grad)
        clip_factor = min(1.0, clip_norm / (grad_norm + 1e-8))
        clipped.append(grad * clip_factor)

    # Average clipped gradients
    avg_grad = np.mean(clipped, axis=0)

    # Add calibrated Gaussian noise
    noise = np.random.normal(0, noise_scale * clip_norm / len(gradients), avg_grad.shape)
    noisy_grad = avg_grad + noise

    return {
        "update": -lr * noisy_grad,
        "avg_clip_factor": np.mean([min(1, clip_norm / (np.linalg.norm(g) + 1e-8)) for g in gradients]),
        "noise_magnitude": np.linalg.norm(noise),
    }

# Simulate with 4 per-sample gradients
grads = [np.random.randn(10) * s for s in [0.5, 2.0, 0.3, 1.5]]
result = dp_sgd_step(grads, clip_norm=1.0, noise_scale=0.5, lr=0.01)
print(f"Avg clip factor: {result['avg_clip_factor']:.3f}")
print(f"Noise magnitude: {result['noise_magnitude']:.4f}")

3. IP Ownership of LLM Outputs

def anonymize_text(text: str, entities: dict) -> str:
    """Replace identified entities with consistent pseudonyms."""
    pseudonym_map = {}
    counter = {}

    for entity_type, values in entities.items():
        counter[entity_type] = 0
        for value in values:
            if value not in pseudonym_map:
                counter[entity_type] += 1
                pseudonym_map[value] = f"[{entity_type}_{counter[entity_type]}]"

    result = text
    for original, pseudonym in pseudonym_map.items():
        result = result.replace(original, pseudonym)

    return result

text = "John Smith from Acme Corp called about order 12345."
anon = anonymize_text(text, {
    "PERSON": ["John Smith"],
    "ORG": ["Acme Corp"],
    "ID": ["12345"],
})
print(anon)