Encontrar datos personales

Unos 40 minutos de lectura, con 11 ejemplos en 13 secciones.

Edición 2026.11.31 Ejemplos verificados el 19 de nov de 2026 108 de 108 ejemplos pasan Qué ha cambiado

Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros

Traducido del libro en inglés, edición 2026.11.31. Lee el original

Al final de este capítulo podrás encontrar datos personales en una plataforma de datos de forma automática, y decir qué proporción de ellos se te escapa. Propondrás una clasificación para cada columna a partir de su nombre, su tipo y una muestra reproducible de sus valores; encontrarás datos personales dentro de texto libre, tramo por tramo; y medirás cada detector frente a datos etiquetados antes de que nadie confíe en él. Por el camino ejecutarás los reconocedores basados en patrones de Presidio sin conexión, con umbrales elegidos mediante medición, los compararás con las detecciones registradas de un modelo entrenado para encontrar datos personales, y volverás a clasificar solo las columnas que añada un cambio de esquema.

Cada columna de la plataforma ya tiene una clasificación. El capítulo 2 puso una en governance/metadata.toml, un archivo que revisan las personas, y un archivo revisado registra lo que sus revisores creen que contiene una columna. En la plataforma, la plataforma de aprendizaje en línea cuyo almacén de datos gobierna este libro, tres de esas creencias nunca se han comprobado. billing.payments.card_number es una columna heredada cuya descripción dice que guarda números de tarjeta completos, y nadie lo ha revisado. crm.learners.notes es texto libre que escriben los agentes de soporte, así que su nombre no dice nada sobre lo que contiene. Las personas que aprenden escriben lo que quieren en los tickets de soporte y en las reseñas de los cursos. Ninguna clasificación de una columna completa puede proteger ese texto. Antes de que pueda enmascararse, la plataforma tiene que encontrar cada nombre, correo electrónico y número de teléfono que contenga, tramo por tramo, como hace el capítulo 9 con las reseñas antes de que el asistente del curso aprenda de ellas.

Este capítulo construye el módulo compartido del libro para esa tarea, lib.pii: reglas sobre los nombres de las columnas, muestras sembradas de los valores de una columna, un detector de Presidio configurado para funcionar sin conexión y código que puntúa cualquier detector frente a datos etiquetados. Cada detector de este capítulo se mide contra un único archivo, que llamamos la verdad: data/platform/pii_spans.parquet. El generador de datos de la plataforma lo escribe junto a los tickets y las reseñas, con cada dato personal que colocó en su texto y su inicio y fin exactos. Los números de factura, los números de pedido y la fecha en que ocurrió un problema permanecen sin etiquetar, porque la plataforma no los trata como datos personales.

Los números de teléfono, los números de tarjeta y los IBAN de este libro son aleatorios, como dice la ficha de datos, y ningún ejemplo muestra uno completo: cada ejemplo enmascara todos los dígitos salvo los cuatro últimos.

Clasifica las columnas a partir del esquema

Último cambio en la edición 2026.11.27

La evidencia más barata sobre una columna es su esquema: su nombre y su tipo. Una regla sobre nombres no lee datos, así que se ejecuta sobre un catálogo completo en una solicitud de cambios, y atrapa las columnas cuyos nombres dicen qué contienen, como email o date_of_birth. Las herramientas de catálogo empiezan de la misma manera: la clasificación automática de OpenMetadata comienza con un escáner de nombres de columna que compara los nombres con expresiones regulares (documentación de OpenMetadata). El tipo decide lo que sigue. Los valores de una columna de texto pueden muestrearse y escanearse, pero una marca de tiempo no puede contener un correo electrónico, y escanearla con un patrón de fecha marcaría cada fila. Por eso, los números, las fechas, las marcas de tiempo y los booleanos se clasifican solo por nombre.

La plataforma guarda sus reglas en governance/pii.toml, que contiene cada ajuste de su detector y se revisa igual que los metadatos. Las reglas son expresiones regulares 8 sobre nombres de columna en minúsculas, cada una con el nombre de la entidad que sugiere, y gana la primera coincidencia. El mismo archivo asigna a cada entidad una clasificación: un número de teléfono a personal, un número de tarjeta o un IBAN a sensitive. lib.pii.by_name aplica las reglas. Las reglas recorren cada columna del catálogo, y los resultados quedan junto a los metadatos revisados:

column-name-rules.py Python 3.12.15 · duckdb 2.0.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · tldextract 5.4.0 Superado
"""Runs the name rules over every column of the catalog and compares each column they mark with the reviewed metadata.The prose rests on the count of marked columns that agree, and on the personal columns no rule marks."""from pyiceberg.types import StringTypefrom lib import metadata, piifrom lib.catalog import open_catalogcatalog = open_catalog()described = metadata.load()                   # the reviewed metadata, keyed by table and then by field ID# every column as (table, field): the field carries the ID the metadata is keyed by, so a renamed column still matchescolumns = [(table, f) for (namespace,) in sorted(catalog.list_namespaces())           for _, name in sorted(catalog.list_tables(namespace))           for table in [f"{namespace}.{name}"] for f in catalog.load_table(table).schema().fields]print("columns in the catalog:", len(columns))print("name rules:", len(pii.NAME_RULES))named = [(table, f, pii.by_name(f.name)) for table, f in columns if pii.by_name(f.name)]print("columns a name rule marks:", len(named))for table, f, entity in named:    print(f"  {table}.{f.name}: {entity}, so {pii.CLASSIFICATION[entity]}")agree = sum(pii.CLASSIFICATION[entity] == described[table].columns[f.field_id].classification            for table, f, entity in named)print("of them, agreeing with the metadata:", agree)# Only text is sampled: numbers, dates, timestamps and booleans are classified by name alone.text = [(table, f) for table, f in columns if isinstance(f.field_type, StringType)]print("columns of text, whose values can be sampled:", len(text))# Columns the metadata, reviewed by people, calls personal or sensitive, that no name rule marks.missed = [f"{table}.{f.name}" for table, f in columns if not pii.by_name(f.name)          and described[table].columns[f.field_id].classification in ("personal", "sensitive")]print("personal columns no name rule marks:", ", ".join(missed))
Salidapython column-name-rules.py
columns in the catalog: 64
name rules: 8
columns a name rule marks: 11
  billing.payments.card_number: CREDIT_CARD, so sensitive
  crm.instructors.full_name: PERSON, so personal
  crm.instructors.email: EMAIL_ADDRESS, so personal
  crm.instructors.payout_iban: IBAN_CODE, so sensitive
  crm.learners.full_name: PERSON, so personal
  crm.learners.email: EMAIL_ADDRESS, so personal
  crm.learners.phone: PHONE_NUMBER, so personal
  crm.learners.city: LOCATION, so personal
  crm.learners.street_address: LOCATION, so personal
  crm.learners.date_of_birth: DATE_TIME, so personal
  learning.events.ip_address: IP_ADDRESS, so personal
of them, agreeing with the metadata: 11
columns of text, whose values can be sampled: 29
personal columns no name rule marks: crm.learners.notes, learning.reviews.body, support.tickets.body

Las reglas coinciden con los metadatos allí donde se activan, y no detectan el texto libre. De las 64 columnas del catálogo, las reglas marcan 11, y las 11 coinciden con la clasificación que les dieron las personas. No detectan tres columnas que los revisores clasificaron como personal: crm.learners.notes, learning.reviews.body y support.tickets.body. Las tres son texto libre, donde el nombre describe el contenedor, no su contenido. La columna marcada que más preocupa a la plataforma, billing.payments.card_number, recibe sensitive por su nombre sin que nadie sepa qué contiene. Los números de tarjeta completos, los últimos cuatro dígitos o un token de un proveedor de pagos coincidirían todos con card_?(number|num|no).

Las reglas por nombre son frágiles de una manera conocida. Los autores de Sherlock, un modelo para detectar tipos de columna, informan de que la comparación por nombre no es robusta ante datos sucios y solo detecta unos pocos tipos (Hulsebos et al., 2019). Por eso la plataforma también lee valores, en las 29 columnas de texto que contiene su catálogo.

Regla práctica: Ejecuta primero las reglas por nombre sobre cada columna, porque son gratuitas, y permite que solo suban una clasificación, nunca que la bajen. Mantén las reglas breves, en código y revisadas como cualquier otra regla. Trata cualquier columna de texto libre, sea cual sea su nombre, como una que necesita muestreo de valores, y clasifica las columnas de otros tipos solo por nombre.

Ejecutar Presidio sin conexión

Último cambio en la edición 2026.11.31

Para leer valores, la plataforma usa Presidio, una biblioteca de código abierto para encontrar y enmascarar datos personales. El analizador de Presidio ejecuta reconocedores: expresiones regulares con sumas de verificación, análisis de números de teléfono y un modelo de entidades nombradas al que se accede mediante un motor de PLN. El motor de PLN cumple dos funciones: el reconocimiento de entidades nombradas y la extracción de características para las reglas, como las palabras de contexto que elevan una puntuación. Su modelo predeterminado es en_core_web_lg de spaCy (documentación de Presidio). En 2.2.366, AnalyzerEngine() sin argumentos descarga ese modelo cuando no está instalado (fuente). Por lo tanto, una canalización sin acceso a la red falla en su primera línea, y una que sí tiene acceso instala un modelo de unos 400 MB como efecto secundario (en_core_web_lg 3.8.0).

lib.pii.detector configura el propio motor con NoOpNlpEngine, que no carga ningún modelo de idioma (fuente). Lo que cuesta esa decisión es el contexto. Con un modelo, Presidio eleva la puntuación de un patrón cuando aparece una palabra como "teléfono" cerca de la coincidencia, comparando el lema de cada palabra cercana con los términos de contexto de cada reconocedor (tutorial de Presidio sobre contexto). Sin modelo no hay lemas, así que el motor no puede usar en absoluto las palabras de contexto del texto. El motor tiene además otra vía hacia la red. Su reconocedor de correo electrónico comprueba los dominios con tldextract, que descarga la Lista de Sufijos Públicos la primera vez que se usa (README de tldextract 5.4.0). Al importar Presidio se importa tldextract, y su README indica que una variable TLDEXTRACT_PUBLIC_SUFFIX_LIST_URLS vacía desactiva la descarga si se define antes de la importación. Por eso lib/__init__.py, que Python ejecuta antes que cualquier módulo de lib del libro, vacía la variable. Si un ejemplo importara Presidio primero, el mismo archivo sustituiría el extractor compartido de tldextract por uno que no tiene URL. lib.pii se niega a cargar si queda alguna, y tldextract usa la copia de la lista que incluye, de modo que el mismo texto da la misma respuesta en cualquier equipo.

Los valores predeterminados se prueban con texto real: se cargan todos los reconocedores predefinidos sobre uno de los tickets de soporte de la plataforma, que contiene un nombre, un correo electrónico, un número de teléfono y una fecha:

presidio-offline-engine.py Python 3.12.15 · duckdb 2.0.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · spacy 3.8.18 · tldextract 5.4.0 Superado
"""Loads Presidio's predefined recognizers on an engine that loads no language model, and runs them on one supportticket. The prose's point rests on the detections printed under the ticket, and on the assert that the model isn'tinstalled."""import spacyfrom lib import piifrom lib.platform import load# AnalyzerEngine() with no arguments loads spaCy's en_core_web_lg, and downloads it when it isn't installed.installed = spacy.util.is_package("en_core_web_lg")assert installed is False       # the pipeline assumes no model: a machine that has one fails here, not silentlyprint("en_core_web_lg installed:", installed)print("URLs tldextract would fetch the Public Suffix List from:", len(pii.suffix_list_urls()))detector = pii.detector()              # every predefined recognizer, on an NLP engine that loads no modelnames = sorted(r.name for r in detector.registry.recognizers)print("recognizers loaded:", len(names))print("recognizers:", ", ".join(names))print("default score threshold:", detector.default_score_threshold)# The ticket holds a phone number, which may be in service: masked() prints it with only its last four digits.ticket = pii.texts("tickets")[1421]         # one ticket with a name, an email, a phone number and a date of the problemfound = sorted(pii.detect(detector, ticket))print("ticket 1421:", pii.masked(ticket))for start, end, entity, score in found:    print(f"  {entity} on {pii.masked(ticket[start:end])}: {score:.2f}")# Where is the phone number valid? The recognizer reads it in each of its regions.phone = next(ticket[start:end] for start, end, entity, _ in found if entity == "PHONE_NUMBER")[learner] = [row["learner_id"] for row in load("support.tickets").to_pylist() if row["ticket_id"] == 1421][country] = [row["country"] for row in load("crm.learners").to_pylist() if row["learner_id"] == learner]print("the learner's country:", country)# The recognizer's built-in regions, not the learner's country.print("default regions where it's valid:",      ", ".join(r for r in pii.PhoneRecognizer.DEFAULT_SUPPORTED_REGIONS if pii.valid_phone(phone, r)))
Salidapython presidio-offline-engine.py
en_core_web_lg installed: False
URLs tldextract would fetch the Public Suffix List from: 0
recognizers loaded: 17
recognizers: CreditCardRecognizer, CryptoRecognizer, DateRecognizer, EmailRecognizer, IbanRecognizer, IpRecognizer, MacAddressRecognizer, MedicalLicenseRecognizer, NhsRecognizer, PhoneRecognizer, UrlRecognizer, UsBankRecognizer, UsItinRecognizer, UsLicenseRecognizer, UsPassportRecognizer, UsSsnRecognizer, UuidRecognizer
default score threshold: 0
ticket 1421: I can't open the videos in Introduction to Design Systems, they stop after a few seconds. It happened on 12/03 around 9pm. My colleague Jennifer Abbott (jennifer.abbott@example.net) wants to enrol as well. You can reach me on •••••••0440 after 6pm.
  DATE_TIME on 12/03: 0.10
  EMAIL_ADDRESS on jennifer.abbott@example.net: 1.00
  URL on example.net: 0.50
  PHONE_NUMBER on •••••••0440: 0.40
  US_BANK_NUMBER on •••••••0440: 0.05
  US_DRIVER_LICENSE on •••••••0440: 0.01
the learner's country: US
default regions where it's valid: BR

Los valores predeterminados de este motor detectan el correo electrónico y el número de teléfono, y no detectan el nombre del compañero. en_core_web_lg no está instalado, así que un AnalyzerEngine() sin más intentaría descargarlo, y tldextract tiene 0 URL desde las que descargar su lista. El motor sin modelo carga 17 reconocedores, y ninguno busca nombres, así que Jennifer Abbott, la colega del ticket, pasa inadvertida. Su correo se encuentra con una puntuación de 1.00, y su dominio se encuentra de nuevo como URL, con 0.50. El número de teléfono del alumno, un número de 11 dígitos escrito sin separadores, se encuentra tres veces: como número de teléfono con 0.40, como número de cuenta bancaria de EE. UU. con 0.05 y como licencia de conducir de EE. UU. con 0.01. Incluso el número de teléfono se detecta por casualidad. El país del alumno es US, pero de las regiones predeterminadas de Presidio, entre ellas EE. UU., los dígitos solo son válidos en BR. La fecha del problema, 12/03, también se lee como fecha, lo cual no dice nada sobre nadie.

Esas puntuaciones no son probabilidades. Cada patrón tiene una puntuación constante, y los patrones débiles reciben puntuaciones bajas, como explica el tutorial de Presidio para un código postal de cinco dígitos (documentación de Presidio). Un número de cuenta bancaria de EE. UU. es cualquier secuencia de 8 a 17 dígitos (entidades admitidas), y las preguntas frecuentes admiten que una licencia de conducir "podría ser cualquier número de 9 dígitos" (preguntas frecuentes). El umbral predeterminado del analizador es 0, así que se devuelven todas las coincidencias débiles.

Regla práctica: Configura explícitamente el motor de Presidio: NoOpNlpEngine cuando ejecutes solo patrones, o un modelo fijado que instales tú mismo cuando necesites sus nombres. No llames nunca a AnalyzerEngine() sin más en una canalización, y fija cualquier cosa que un reconocedor pudiera descargar, como la Lista de Sufijos Públicos. Lee cada puntuación como una constante establecida para su patrón, nunca como una probabilidad.

Muestrea los valores de una columna de la misma forma en cada ejecución

Último cambio en la edición 2026.11.27

Recorrer todos los valores de todas las columnas de texto es demasiado lento para cualquier almacén de datos, así que las herramientas muestrean. El flujo de trabajo de OpenMetadata muestrea filas y las revisa con un motor de reconocimiento de entidades (documentación de OpenMetadata). Una muestra requiere tres decisiones. Qué filas: una muestra aleatoria, no las primeras filas ni un bloque desde un inicio aleatorio. Sensitive Data Protection de Google ofrece un modo de inicio aleatorio, RANDOM_START, que empieza en una fila al azar y sigue leyendo (documentación de Google Cloud). En una tabla ordenada por fecha de registro, ese bloque es una sola cohorte de estudiantes. Las mismas filas en cada ejecución, para que una clasificación pueda reproducirse y un cambio en ella signifique que los datos cambiaron. Y cuántas, según lo rara que sea la información que debes detectar.

La muestra de embalse de DuckDB acepta una semilla, pero una semilla produce una muestra reproducible solo cuando DuckDB se ejecuta en un único hilo, como advierte la documentación de DuckDB 2.0.0. lib.pii.sample fija un solo hilo, descarta los NULL y después extrae una muestra de embalse con semilla.

Un valor raro necesita una muestra más grande, y la aritmética indica cuánto más grande. Llamemos p a la proporción de valores que contienen datos personales. La probabilidad de que n valores muestreados incluyan al menos uno es

probabilidad = 1 − (1 − p)ⁿ

y la n que da una probabilidad del 99% es ln(0.01) / ln(1 − p). Esta es una regla práctica: trata los sorteos como independientes, lo que una muestra sin reemplazo de miles de filas casi cumple.

Pongamos la fórmula en práctica: extraiga 20 notas de crm.learners dos veces, y luego compare las probabilidades sobre todas las filas con las probabilidades sobre las notas solamente.

seeded-column-sample.py Python 3.12.15 · duckdb 2.0.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · tldextract 5.4.0 Superado
"""Draws the same twenty notes twice from a seeded reservoir sample, then counts the notes that hold personal data, to seehow many sampled values a rare value needs. The prose rests on the assert that the draws match, the two chances and the sample sizes."""import mathfrom lib import piifrom lib.catalog import open_catalogfrom lib.warehouse import connectcon = connect(open_catalog(["crm.learners"]))first = pii.sample(con, "crm.learners", "notes", rows=20)second = pii.sample(con, "crm.learners", "notes", rows=20)     # the same call: the seed and one thread (set in lib.pii.sample) make the draws matchassert second == firstprint("second draw, same notes as the first:", "yes" if second == first else "no")# Notes can hold a phone number, which may be in service: masked() prints it with only its last four digits.print("first sampled notes:", " | ".join(pii.masked(note) for note in first[:3]))# How rare is personal data in the column? Run the detector over every note, once, to know.detector = pii.platform_detector()[(rows, notes)] = con.sql("select count(*), count(notes) from crm.learners").fetchall()   # count(notes) skips NULLsevery_note = [note for (note,) in con.sql("select notes from crm.learners where notes is not null").fetchall()]holding = sum(bool(pii.detect(detector, note)) for note in every_note)print("learners:", f"{rows:,}")print("learners with notes:", notes)print("notes holding personal data the detector finds:", holding)# The chance that n sampled values hold at least one of them is 1 - (1 - p)^n, for a share p of the values.for unit, p in (("rows", holding / rows), ("notes", holding / notes)):   # p counted over all learners, then over the notes    print(f"chance 20 sampled {unit} catch one:", f"{1 - (1 - p) ** 20:.1%}")    print(f"sampled {unit} needed for a 99% chance:", math.ceil(math.log(0.01) / math.log(1 - p)))   # solves for nprint("values the platform samples per text column:", pii.ROWS)# The rarest share p that a sample of ROWS values still catches 99% of the time, printed as 1 in a whole number.print("rarest share that sample catches 99% of the time:", f"1 in {math.floor(1 / (1 - 0.01 ** (1 / pii.ROWS)))}")
Salidapython seeded-column-sample.py
second draw, same notes as the first: yes
first sampled notes: VIP: bought a team licence. | Asked about invoices for their employer. | Called about a refund, call back on (•••)•••-1366x•••.
learners: 5,000
learners with notes: 527
notes holding personal data the detector finds: 138
chance 20 sampled rows catch one: 42.9%
sampled rows needed for a 99% chance: 165
chance 20 sampled notes catch one: 99.8%
sampled notes needed for a 99% chance: 16
values the platform samples per text column: 200
rarest share that sample catches 99% of the time: 1 in 43

Los sorteos se repiten, así que una muestra puede auditarse. Con la misma semilla, el segundo sorteo devuelve las mismas 20 notas, y la tercera nota ya contiene un número de teléfono, que la salida enmascara.

De los 5,000 estudiantes, 527 tienen notas, y 138 de esas contienen datos personales que el detector de la plataforma, ajustado más adelante en este capítulo, encuentra. Los NULL diluyen la muestra, ya que un NULL no puede contener datos personales. Veinte filas muestreadas detectan datos personales el 42.9% de las veces, y una probabilidad del 99% requiere 165 filas. Contando solo las notas que existen, veinte detectan datos personales el 99.8% de las veces, y se necesitan 16 para alcanzar el 99%.

Regla práctica: Muestrea valores no nulos, con una semilla fija, en un solo hilo, y guarda la semilla junto con el resultado. Dimensiona la muestra según los datos personales más raros que debas detectar, con n = ln(0.01) / ln(1 − p) para el 99%. La plataforma muestrea 200 valores por columna de texto, configurado en governance/pii.toml, lo que detecta datos personales presentes en 1 in 43 valores o más el 99% de las veces. Para algo más raro, examine la columna completa o clasifíquela mediante una regla.

Clasificar columnas a partir de sus valores

Último cambio en la edición 2026.11.28

Las reglas de nombres y una muestra reproducible se combinan en una sola propuesta por columna. lib.pii.classify toma la clasificación más estricta que cualquiera de las dos respalda: la entidad que sugiere el nombre y cada entidad encontrada en cualquiera de los valores muestreados. Una columna sin evidencia recibe internal, porque un detector que no encontró nada no ha demostrado nada, y solo una persona decide que una columna es public.

Lo más estricto es una elección. La herramienta propia de Presidio para tablas, Presidio structured, asigna a cada columna una sola entidad, y su valor predeterminado, Most Common, elige la entidad que aparece con más frecuencia (documentación de Presidio). Eso sirve para decidir cómo enmascarar una columna. Para clasificarla, una columna que contiene un número de tarjeta en 200 valores sigue conteniendo números de tarjeta.

Las propuestas para cada columna del catálogo, generadas por el detector de la plataforma, cuyos reconocedores una sección posterior elige, muestran en qué se diferencia cada una de los metadatos revisados:

classify-sampled-columns.py Python 3.12.15 · duckdb 2.0.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · tldextract 5.4.0 Superado
"""Proposes a classification for every column, the strictest of what its name and its sampled values support, and compareseach proposal with the reviewed metadata. The prose's table rests on the proposed and found lines of each column, andits counts on the totals printed after them."""from lib import metadata, piifrom lib.catalog import open_catalogfrom lib.warehouse import connectcatalog = open_catalog()findings = pii.classify(catalog, connect(catalog), pii.platform_detector())    # the platform's tuned detector, not the defaultsprint("columns classified:", len(findings))print("columns sampled:", sum(f.sampled > 0 for f in findings))holding = [f for f in findings if f.found]          # columns where sampled values hold personal dataprint("columns whose sampled values hold personal data:", len(holding))# A column counts when its values hold an entity other than the one its name suggests (named is None when no rule matches).print("of them, holding something their name doesn't suggest:", sum(set(f.found) != {f.named} for f in holding))for f in holding:    print(f"{f.table}.{f.column}, proposed: {f.classification}")    print(f"{f.table}.{f.column}, found: " + ", ".join(f"{e} in {n} of {f.sampled}" for e, n in f.found.most_common()))[cards] = [f for f in findings if f.column == "card_number"]     # the one card_number column in the catalog# The card recognizer's count: values that match its pattern and pass its Luhn check, out of the values sampled.print("sampled card numbers the card recognizer accepts:", f"{cards.found['CREDIT_CARD']} of {cards.sampled}")# Classifications the values raise above what the name alone gives: the floor is used for a name no rule matches.named_only = [f for f in findings if pii.CLASSIFICATION.get(f.named, pii.FLOOR) != f.classification]print("columns the values classify more strictly than the name:", ", ".join(f"{f.table}.{f.column}" for f in named_only))# Compare with the metadata people reviewed. A column the detector found nothing in proposes only the floor, internal.described = metadata.load()evidenced = [f for f in findings if f.named or f.found]print("columns with evidence:", len(evidenced))print("of them, equal to the metadata:",      sum(f.classification == described[f.table].columns[f.field_id].classification for f in evidenced))for f in evidenced:    reviewed = described[f.table].columns[f.field_id].classification    if metadata.stricter(f.classification, reviewed) != reviewed:     # the stricter of the two: a lower proposal prints nothing        print(f"stricter than the metadata, {f.table}.{f.column}: {f.classification}, reviewed as {reviewed}")
Salidapython classify-sampled-columns.py
columns classified: 64
columns sampled: 29
columns whose sampled values hold personal data: 9
of them, holding something their name doesn't suggest: 5
billing.payments.card_number, proposed: sensitive
billing.payments.card_number, found: CREDIT_CARD in 151 of 200, PHONE_NUMBER in 3 of 200
crm.instructors.email, proposed: personal
crm.instructors.email, found: EMAIL_ADDRESS in 50 of 50
crm.instructors.payout_iban, proposed: sensitive
crm.instructors.payout_iban, found: IBAN_CODE in 50 of 50
crm.learners.email, proposed: personal
crm.learners.email, found: EMAIL_ADDRESS in 200 of 200
crm.learners.phone, proposed: personal
crm.learners.phone, found: PHONE_NUMBER in 175 of 200
crm.learners.notes, proposed: personal
crm.learners.notes, found: PHONE_NUMBER in 29 of 200, EMAIL_ADDRESS in 18 of 200
learning.events.ip_address, proposed: personal
learning.events.ip_address, found: IP_ADDRESS in 200 of 200, PHONE_NUMBER in 39 of 200
learning.reviews.body, proposed: personal
learning.reviews.body, found: EMAIL_ADDRESS in 4 of 200
support.tickets.body, proposed: sensitive
support.tickets.body, found: EMAIL_ADDRESS in 47 of 200, PHONE_NUMBER in 37 of 200, DATE_TIME in 29 of 200, IBAN_CODE in 21 of 200, CREDIT_CARD in 12 of 200
sampled card numbers the card recognizer accepts: 151 of 200
columns the values classify more strictly than the name: crm.learners.notes, learning.reviews.body, support.tickets.body
columns with evidence: 14
of them, equal to the metadata: 13
stricter than the metadata, support.tickets.body: sensitive, reviewed as personal

Los valores resuelven lo que los nombres dejan abierto. Algunas de las 9 columnas cuyas muestras contienen datos personales contienen solo lo que su nombre indica, como crm.learners.email. Las otras 5 contienen algo que su nombre no sugiere, o tienen un nombre que no sugiere nada:

Columna Propuesta Encontrado en la muestra
billing.payments.card_number sensitive CREDIT_CARD in 151 of 200, PHONE_NUMBER in 3 of 200
crm.learners.notes personal PHONE_NUMBER in 29 of 200, EMAIL_ADDRESS in 18 of 200
support.tickets.body sensitive EMAIL_ADDRESS in 47 of 200, PHONE_NUMBER in 37 of 200, DATE_TIME in 29 of 200, IBAN_CODE in 21 of 200, CREDIT_CARD in 12 of 200
learning.reviews.body personal EMAIL_ADDRESS in 4 of 200
learning.events.ip_address personal IP_ADDRESS in 200 of 200, PHONE_NUMBER in 39 of 200

La descripción de la columna de tarjeta heredada dice que "no debería almacenarse en absoluto", y la muestra revela que contiene números de tarjeta completos, algo sobre lo que team-billing, el propietario de la tabla, puede actuar. De los números de tarjeta muestreados, 151 of 200 coinciden con el patrón de tarjeta de Presidio y superan la suma de control de Luhn que este comprueba (fuente), y el resto son formatos que el patrón no cubre (mira dónde fallan los patrones). Las notas son personal solo por sus valores. El texto de los tickets es sensitive, porque los estudiantes pegan números de tarjeta e IBAN en los tickets, lo que lo convierte en la única propuesta más estricta que los metadatos, donde las personas lo revisaron como personal. De las 14 columnas con alguna evidencia, 13 coinciden con la clasificación revisada.

Lee la evidencia, no solo el veredicto. Algunas direcciones IP también se interpretan como números de teléfono. Eso no cambia nada aquí, porque una dirección IP es personal de todos modos, pero la etiqueta de un detector indica cómo se ve un valor, no lo que es.

Regla práctica: Propón la clasificación más estricta que respalden el nombre o cualquiera de los valores muestreados, con internal como mínimo, y muestra la evidencia junto con la propuesta. Una propuesta más estricta que los metadatos revisados es un hallazgo para el propietario de la tabla, quien eleva la clasificación o registra por qué no lo hace; nunca permitas que un detector la rebaje. OpenMetadata omite cualquier columna que ya tenga una etiqueta PII; recomendamos muestrear en cambio cada columna de texto en cada ejecución, porque la etiqueta revisada es precisamente lo que se está comprobando.

Medir un detector contra spans etiquetados

Último cambio en la edición 2026.11.31

Una respuesta a nivel de columna basta para clasificar support.tickets.body, pero no para enmascararlo: enmascarar reemplaza cada span de datos personales en cada texto, y un span que el detector no encuentra queda legible. Para saber qué omite un detector, compara sus spans con la verdad, los spans etiquetados de cada ticket y reseña. Hay dos reglas de coincidencia estándar, y lib.pii aplica ambas.

La coincidencia exacta, de la tarea compartida CoNLL-2003, cuenta una entidad "correcta solo si coincide exactamente con la entidad correspondiente en el archivo de datos" (Tjong Kim Sang and De Meulder, 2003). La coincidencia por solapamiento solo exige un carácter compartido, con una etiqueta de su mismo tipo, lo que la tarea SemEval-2013 sobre interacciones farmacológicas llama "Type matching" (Segura-Bedmar et al., 2013). Ninguna de las dos acredita un span oculto bajo otra etiqueta, así que lib.pii añade una tercera medida, la cobertura: si cada carácter de un span etiquetado queda dentro de alguna detección, sea cual sea su etiqueta. La exacta pregunta si el detector etiquetó bien el span completo, el solapamiento si notó que el span es lo que es, y la cobertura si enmascarar sus detecciones oculta el span.

lib.pii.score calcula las coincidencias exacta y por solapamiento como exhaustividad (recall), la proporción de spans etiquetados de cada tipo que un detector encuentra con una etiqueta de ese tipo, y como precisión, la proporción de detecciones de cada etiqueta que coinciden con un span etiquetado. lib.pii.coverage indica la proporción de spans de cada tipo cubiertos. score cuenta además los textos en los que cada carácter etiquetado cae dentro de alguna detección, es decir, los textos que el enmascaramiento dejaría sin datos personales. El Text Anonymization Benchmark protege a una persona solo cuando todas sus menciones están enmascaradas (Pilán et al., 2022), y la plataforma cuenta textos completos, lo que es más estricto. La exhaustividad va primero: la guía de evaluación de Presidio dice que a menudo importa más que la precisión, porque omitir datos personales es el error que hay que evitar (Presidio docs).

Los valores por defecto de Presidio, puntuados contra los spans etiquetados de cada ticket y reseña, dan la línea base que el resto del capítulo mejora:

measure-pattern-recognizers.py Python 3.12.15 · duckdb 2.0.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · tldextract 5.4.0 Superado
"""Runs Presidio with its defaults over every ticket and review, and scores its detections against the truth's labelledspans. The prose rests on the recall and precision lines, the count of texts left with nothing personal, and the twodate lines that test the truth's limits."""import refrom lib import piilabelled = pii.truth()print("texts:", f"{sum(len(pii.texts(source)) for source in pii.SOURCES):,}")print("labelled spans:", f"{len(labelled):,}")detector = pii.detector()                 # Presidio's defaults: every recognizer, threshold 0found = pii.find(detector)# scoring needs a label of the span's type; coverage doesn'tscores, covered = pii.score(found, labelled), pii.coverage(found, labelled)print("detections:", f"{len(found):,}")for entity, (n, exact, overlap) in scores.recall.items():    print(f"{entity}, labelled: {n:,}")    print(f"{entity}, recall, exact: {exact / n:.2f}")    print(f"{entity}, recall, overlap: {overlap / n:.2f}")    print(f"{entity}, covered, any label: {covered[entity][1] / n:.2f}")    # covered[entity] is (spans, covered), so n is the same countfor label, (n, exact, overlap) in scores.precision.items():     # precision is per label: what each detection was called    print(f"{label}, detections: {n:,}")    print(f"{label}, precision, exact: {exact / n:.2f}")# every bank number and driver's licence detection is a false alarm: none matches a labelled spanassert all(scores.precision[entity][1] == 0 for entity in ("US_BANK_NUMBER", "US_DRIVER_LICENSE"))print("precision of all detections, exact:", f"{pii.precision_overall(scores):.2f}")print("texts holding personal data:", f"{scores.texts:,}")print("texts with every labelled span masked:", f"{scores.masked:,}")# The truth's limits. The generator builds every text from a few sentence templates, and writes every date of birth# one way. Presidio's date patterns don't read every way of writing one.print("sentence templates the texts are built from:", len(pii.templates()))births = [pii.text_of(s) for s in labelled if s.entity == "DATE_TIME"]    # the truth's dates are the dates of birth: dates of a problem are unlabelledwritten_ymd = sum(re.fullmatch(r"\d{4}-\d\d-\d\d", d) is not None for d in births)   # year first, the generator's one formassert written_ymd == len(births)           # so every date of birth is written this wayprint("dates of birth written like 1985-03-12:", written_ymd)for written in ("1985-03-12", "12 March 1985"):    text = f"My date of birth on the account is wrong, it should be {written}."     # a sentence in the generator's shape    print(f"dates found in a date of birth written {written}:", sum(e == "DATE_TIME" for _, _, e, _ in pii.detect(detector, text)))
Salidapython measure-pattern-recognizers.py
texts: 5,000
labelled spans: 4,292
detections: 3,902
CREDIT_CARD, labelled: 213
CREDIT_CARD, recall, exact: 0.71
CREDIT_CARD, recall, overlap: 0.71
CREDIT_CARD, covered, any label: 0.89
DATE_TIME, labelled: 196
DATE_TIME, recall, exact: 1.00
DATE_TIME, recall, overlap: 1.00
DATE_TIME, covered, any label: 1.00
EMAIL_ADDRESS, labelled: 543
EMAIL_ADDRESS, recall, exact: 1.00
EMAIL_ADDRESS, recall, overlap: 1.00
EMAIL_ADDRESS, covered, any label: 1.00
IBAN_CODE, labelled: 236
IBAN_CODE, recall, exact: 1.00
IBAN_CODE, recall, overlap: 1.00
IBAN_CODE, covered, any label: 1.00
LOCATION, labelled: 210
LOCATION, recall, exact: 0.00
LOCATION, recall, overlap: 0.00
LOCATION, covered, any label: 0.00
PERSON, labelled: 2,455
PERSON, recall, exact: 0.00
PERSON, recall, overlap: 0.00
PERSON, covered, any label: 0.00
PHONE_NUMBER, labelled: 439
PHONE_NUMBER, recall, exact: 0.78
PHONE_NUMBER, recall, overlap: 0.79
PHONE_NUMBER, covered, any label: 0.91
CREDIT_CARD, detections: 151
CREDIT_CARD, precision, exact: 1.00
DATE_TIME, detections: 421
DATE_TIME, precision, exact: 0.47
EMAIL_ADDRESS, detections: 543
EMAIL_ADDRESS, precision, exact: 1.00
IBAN_CODE, detections: 236
IBAN_CODE, precision, exact: 1.00
MEDICAL_LICENSE, detections: 18
MEDICAL_LICENSE, precision, exact: 0.00
PHONE_NUMBER, detections: 384
PHONE_NUMBER, precision, exact: 0.89
UK_NHS, detections: 8
UK_NHS, precision, exact: 0.00
URL, detections: 751
URL, precision, exact: 0.00
US_BANK_NUMBER, detections: 689
US_BANK_NUMBER, precision, exact: 0.00
US_DRIVER_LICENSE, detections: 683
US_DRIVER_LICENSE, precision, exact: 0.00
US_ITIN, detections: 2
US_ITIN, precision, exact: 0.00
US_PASSPORT, detections: 8
US_PASSPORT, precision, exact: 0.00
US_SSN, detections: 8
US_SSN, precision, exact: 0.00
precision of all detections, exact: 0.38
texts holding personal data: 2,586
texts with every labelled span masked: 425
sentence templates the texts are built from: 30
dates of birth written like 1985-03-12: 196
dates found in a date of birth written 1985-03-12: 1
dates found in a date of birth written 12 March 1985: 0
Tipo de entidad Etiquetados Exhaustividad, exacta Exhaustividad, solapamiento Cubiertos
PERSON 2,455 0.00 0.00 0.00
EMAIL_ADDRESS 543 1.00 1.00 1.00
PHONE_NUMBER 439 0.78 0.79 0.91
IBAN_CODE 236 1.00 1.00 1.00
CREDIT_CARD 213 0.71 0.71 0.89
LOCATION 210 0.00 0.00 0.00
DATE_TIME 196 1.00 1.00 1.00

Los valores por defecto encuentran todos los correos, IBAN y fechas de nacimiento, la mayoría de los números de teléfono y tarjeta, y ningún nombre ni dirección postal, que es buena parte de lo que contienen los tickets. La mayor parte de lo que marcan está mal: 0.38 de todas las detecciones coinciden con un span etiquetado. Los 689 números bancarios de EE. UU., las 683 licencias de conducir y las 751 URL son todos errores. Los números de teléfono, tarjeta y factura, que son secuencias de dígitos, salen como números bancarios y licencias, y fragmentos de correos y algunas direcciones salen como URL. Una etiqueta equivocada aún oculta los dígitos, así que los números de teléfono y tarjeta se cubren más a menudo de lo que se encuentran.

El enmascaramiento dejaría datos personales en la mayoría de los textos que los contienen. Solo 425 de los 2,586 textos quedarían sin ningún dato personal.

La verdad también tiene sus límites, porque el texto es generado. Cada ticket y reseña se construye a partir de 30 plantillas de oración en prep/generate.py, así que cada caso difícil es un marco de oración, y todas las 196 fechas de nacimiento se escriben como 1985-03-12. La exhaustividad de fechas de 1.00 mide, por tanto, un solo formato: en la oración propia del generador, Presidio encuentra 1 fechas cuando la fecha de nacimiento se escribe 1985-03-12, y 0 cuando se escribe 12 March 1985. Una medida sobre este texto indica cómo se comporta un detector con estas formas, no cómo lo hará con las tuyas.

Regla práctica: Mide cada detector contra spans etiquetados antes de que enmascare nada: exhaustividad por tipo de entidad con coincidencia exacta y por solapamiento, ambas con una etiqueta del tipo correcto; cobertura sea cual sea la etiqueta; precisión por etiqueta, y la proporción de textos sin datos personales restantes. Pesa primero la exhaustividad. Antes de fiarte de un detector en tu texto, etiqueta a mano unos cientos de registros reales y mide también sobre ellos.

Ajusta los reconocedores frente a la verdad

Último cambio en la edición 2026.11.28

Los valores por defecto de Presidio devuelven cada coincidencia débil. Las preguntas frecuentes nombran dos remedios, cambiar el umbral de aceptación y eliminar los reconocedores que un conjunto de datos no necesita, y señalan una compensación entre falsos positivos y falsos negativos (preguntas frecuentes). Presidio 2.2.364 añadió umbrales de puntuación por reconocedor y por entidad, con el valor por defecto del analizador como alternativa (registro de cambios, notas de la versión). El reconocedor de teléfonos tiene una opción más que importa en una plataforma cuyos alumnos viven en muchos países: las regiones cuyos planes de numeración lee (fuente).

governance/pii.toml conserva 6 reconocedores, para los identificadores que puede contener el texto de la plataforma, cada uno con su propio umbral. Las regiones telefónicas no son una opción: lib.pii.countries lee de crm.learners los países en que viven los alumnos, de modo que las regiones siguen a los datos. Cuatro configuraciones se puntúan frente a la misma verdad:

tune-pattern-recognizers.py Python 3.12.15 · duckdb 2.0.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · tldextract 5.4.0 Superado
"""Scores four detector settings against the same truth: Presidio's defaults, one threshold for every recognizer, the keptrecognizers with their own thresholds, and those with phone numbers read in the learners' countries. The prose rests onthe precision, phone recall, coverage and fully masked texts of each setting."""from lib import piilabelled = pii.truth()print("recognizers kept:", len(pii.THRESHOLDS))                  # read from governance/pii.tomlprint("recognizers kept, with their thresholds:", ", ".join(f"{name} {t}" for name, t in pii.THRESHOLDS.items()))print("phone regions, Presidio's default:", ", ".join(pii.PhoneRecognizer.DEFAULT_SUPPORTED_REGIONS))   # Presidio's own listprint("phone regions, the learners' countries:", ", ".join(pii.countries()))   # read from crm.learners# In the order the prose builds them: the defaults, one threshold, the kept recognizers, then their regions.settings = {    "Presidio's defaults": pii.detector(),    "one threshold of 0.5": pii.detector(default_threshold=0.5),    "kept recognizers, own thresholds": pii.detector(pii.THRESHOLDS),    "kept recognizers, learners' phone regions": pii.platform_detector(),}for name, detector in settings.items():    found = pii.find(detector)    scores, covered = pii.score(found, labelled), pii.coverage(found, labelled)    n, exact, _ = scores.recall["PHONE_NUMBER"]         # the table reads exact recall, so the overlap count is left out    print(f"{name}, detections: {len(found):,}")    print(f"{name}, precision, exact: {pii.precision_overall(scores):.2f}")    print(f"{name}, phone recall, exact: {exact / n:.2f}")    # coverage takes a detection under any label    for entity, short in (("PHONE_NUMBER", "phones"), ("CREDIT_CARD", "cards")):        print(f"{name}, {short} covered, any label: {covered[entity][1] / covered[entity][0]:.2f}")    print(f"{name}, texts with every labelled span masked: {scores.masked:,}")
Salidapython tune-pattern-recognizers.py
recognizers kept: 6
recognizers kept, with their thresholds: EmailRecognizer 0.5, PhoneRecognizer 0.4, CreditCardRecognizer 0.5, IbanRecognizer 0.5, DateRecognizer 0.5, IpRecognizer 0.5
phone regions, Presidio's default: US, GB, DE, FR, IL, IN, CA, BR
phone regions, the learners' countries: AU, BR, CA, DE, ES, FR, GB, IN, JP, MX, PL, US
Presidio's defaults, detections: 3,902
Presidio's defaults, precision, exact: 0.38
Presidio's defaults, phone recall, exact: 0.78
Presidio's defaults, phones covered, any label: 0.91
Presidio's defaults, cards covered, any label: 0.89
Presidio's defaults, texts with every labelled span masked: 425
one threshold of 0.5, detections: 1,903
one threshold of 0.5, precision, exact: 0.59
one threshold of 0.5, phone recall, exact: 0.00
one threshold of 0.5, phones covered, any label: 0.01
one threshold of 0.5, cards covered, any label: 0.71
one threshold of 0.5, texts with every labelled span masked: 284
kept recognizers, own thresholds, detections: 1,510
kept recognizers, own thresholds, precision, exact: 0.97
kept recognizers, own thresholds, phone recall, exact: 0.78
kept recognizers, own thresholds, phones covered, any label: 0.78
kept recognizers, own thresholds, cards covered, any label: 0.72
kept recognizers, own thresholds, texts with every labelled span masked: 394
kept recognizers, learners' phone regions, detections: 1,539
kept recognizers, learners' phone regions, precision, exact: 0.97
kept recognizers, learners' phone regions, phone recall, exact: 0.84
kept recognizers, learners' phone regions, phones covered, any label: 0.84
kept recognizers, learners' phone regions, cards covered, any label: 0.72
kept recognizers, learners' phone regions, texts with every labelled span masked: 405
Medida Valores por defecto Un umbral, 0.5 Reconocedores conservados Y las regiones de los alumnos
Detecciones 3,902 1,903 1,510 1,539
Precisión, exacta 0.38 0.59 0.97 0.97
Exhaustividad de teléfonos, exacta 0.78 0.00 0.78 0.84
Teléfonos cubiertos 0.91 0.01 0.78 0.84
Tarjetas cubiertas 0.89 0.71 0.72 0.72
Textos enmascarados por completo 425 284 394 405

La solución evidente falla. Un solo umbral de 0.5 elimina las coincidencias débiles y, con ellas, cada número de teléfono, porque un número de teléfono obtiene 0.40 cuando ninguna palabra de contexto puede elevarlo. Conservar solo los 6 reconocedores, cada uno con su propio umbral, y fijar el umbral del teléfono en la puntuación que obtiene un número de teléfono, eleva la precisión a 0.97 y deja la exhaustividad de teléfonos donde estaba. Leer los números de teléfono en las regiones de los alumnos, en lugar de las regiones por defecto de Presidio, eleva la exhaustividad de teléfonos a 0.84.

Una cifra va en sentido contrario: salen completamente enmascarados menos textos que con los valores por defecto. Los reconocedores eliminados habían enmascarado algunos números de teléfono y de tarjeta con una etiqueta equivocada, lo que aun así oculta los dígitos. Sin ellos, la cobertura baja de 0.91 a 0.78 en los números de teléfono, y de 0.89 a 0.72 en los números de tarjeta. Creemos que la precisión merece el precio, porque las detecciones son la evidencia que lee un revisor, y con los valores por defecto los tickets y las reseñas contienen 689 números bancarios y 683 licencias de conducir, ninguno de ellos real. governance/pii.toml no asigna clasificación a ninguna de las dos entidades, así que no cambia ninguna propuesta, pero cada una es un hallazgo que alguien tiene que leer y descartar. Eliminar los reconocedores de Estados Unidos es también una afirmación sobre el texto de la plataforma: la verdad no contiene números bancarios ni de licencia de Estados Unidos. Si la plataforma llegara a necesitar alguno, esa afirmación, y la medición, tendrían que cambiar.

Regla práctica: Nunca ejecutes con el umbral por defecto de Presidio, que es 0, ni con un solo umbral para todos los reconocedores. Conserva solo los reconocedores de los identificadores que puede contener tu texto, fija el umbral de cada uno a partir de sus propias puntuaciones y lee los números de teléfono en las regiones donde viven tus usuarios, derivadas de tus datos. Pon todo ello en código y vuelve a medir cada vez que cambie.

Detecta dónde fallan los patrones

Último cambio en la edición 2026.11.28

Los reconocedores ajustados puntúan bien en los totales, y los totales ocultan dónde fallan. Un detector basado en patrones falla de tres maneras: no hay patrón para aquello que se busca, su patrón o su validación rechaza el valor, o detecta algo que solo parece personal. Los tickets de la plataforma incluyen casos de cada tipo, tal como indica su ficha de datos: nombres escritos en minúsculas, iniciales, nombres de pila que son palabras comunes, números de teléfono escritos sin separadores, y números de factura, números de pedido y fechas de un problema, que la verdad deja sin etiquetar. Cuenta cada caso con el detector de la plataforma. Un caso cuenta como detectado cuando alguna detección se solapa con él, sea cual sea su etiqueta:

pattern-hard-cases.py Python 3.12.15 · duckdb 2.0.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · tldextract 5.4.0 Superado
"""Counts each hard case the tickets and reviews plant, and each look-alike number or date the platform's detector flags,then checks the card and phone numbers it misses. The prose rests on the caught counts for names and invoice numbers,and on the misses' lengths, first digits and validity."""from collections import Counterfrom lib import piifrom lib.platform import loadlabelled = pii.truth()found = pii.find(pii.platform_detector())cases = pii.hard_cases(labelled)               # a case is caught when some detection overlaps it, whatever its labelfor case, spans in cases.items():    print(f"{case}, labelled: {len(spans)}")    print(f"{case}, caught: {pii.caught(spans, found)}")print("hard cases of a name, caught:", pii.caught([s for spans in cases.values() for s in spans if s.entity == "PERSON"], found))# Look-alikes are numbers and dates that aren't personal data, so any detection on one is a false alarm.for kind, spans in pii.lookalikes().items():    print(f"{kind}, in the tickets: {len(spans)}")    print(f"{kind}, flagged as personal data: {pii.caught(spans, found)}")# Card numbers the card pattern misses: too short or long for its 13 to 17 digits, or a first digit it doesn't accept.# Out of range, the length is the reason; in range, the first digit is, since the pattern accepts only some of them.missed = pii.missed([s for s in labelled if s.entity == "CREDIT_CARD"], found, {"CREDIT_CARD"})why = lambda digits: f"{len(digits)} digits" if not 13 <= len(digits) <= 17 else f"{len(digits)} digits starting with {digits[0]}"print("CREDIT_CARD, missed:", len(missed))for reason, n in Counter(why(pii.text_of(s)) for s in missed).most_common():    print(f"CREDIT_CARD, missed, {reason}: {n}")print("IBAN_CODE, missed:", len(pii.missed([s for s in labelled if s.entity == "IBAN_CODE"], found, {"IBAN_CODE"})))# Are the phone numbers the patterns miss valid where the ticket's learner lives? Phones appear only in tickets,# so each phone's learner comes from its ticket.learner_of = {row["ticket_id"]: row["learner_id"] for row in load("support.tickets").to_pylist()}country_of = {row["learner_id"]: row["country"] for row in load("crm.learners").to_pylist()}phones = pii.missed([s for s in labelled if s.entity == "PHONE_NUMBER"], found, {"PHONE_NUMBER"})print("phone numbers missed:", len(phones))print("of them, invalid in the learner's country:",      sum(not pii.valid_phone(pii.text_of(s), country_of[learner_of[s.row_id]]) for s in phones))
Salidapython pattern-hard-cases.py
names in lowercase, labelled: 211
names in lowercase, caught: 0
initial and surname, labelled: 163
initial and surname, caught: 0
first names that are words, labelled: 187
first names that are words, caught: 0
instructors named in reviews, labelled: 798
instructors named in reviews, caught: 0
phones typed as digits only, labelled: 257
phones typed as digits only, caught: 220
hard cases of a name, caught: 0
invoice numbers, in the tickets: 224
invoice numbers, flagged as personal data: 31
order numbers, in the tickets: 212
order numbers, flagged as personal data: 0
dates of a problem, in the tickets: 225
dates of a problem, flagged as personal data: 0
CREDIT_CARD, missed: 62
CREDIT_CARD, missed, 19 digits: 23
CREDIT_CARD, missed, 12 digits: 22
CREDIT_CARD, missed, 16 digits starting with 2: 10
CREDIT_CARD, missed, 15 digits starting with 2: 7
IBAN_CODE, missed: 0
phone numbers missed: 65
of them, invalid in the learner's country: 63

Los nombres son el hueco, ya que ningún patrón coincide con un nombre. En los nombres en minúsculas, las iniciales con apellido, los nombres de pila que son palabras comunes y los instructores mencionados en las reseñas, los patrones detectan 0 de ellos. Los teléfonos escritos solo con dígitos funcionan bien, 220 de 257. El precio son los valores que se parecen a datos personales: 31 de los 224 números de factura se marcan como datos personales.

El detector de la plataforma marca 0 de los 212 números de pedido y 0 de los 225 fechas de una incidencia. Con los valores por defecto de Presidio, 12/03 se detectó como fecha en 0.10, y el reconocedor de fechas devolvió 421 fechas, donde la verdad etiqueta 196. El umbral de governance/pii.toml evita que entren coincidencias tan débiles.

La forma del patrón de tarjetas causa los fallos con tarjetas. Acepta entre 13 y 17 dígitos que empiezan por 1, 3, 4, 50 a 55 o 6, pero ningún número de 13 dígitos que empiece por 1 (fuente), y todos los números de tarjeta de los datos superan la suma de control de Luhn, así que la validación no rechaza ninguno. De los 62 números de tarjeta que no detecta, 23 tienen 19 dígitos y 22 tienen 12, y el resto empieza por 2, algo que el patrón no acepta.

La validación causa los otros fallos. El reconocedor de IBAN comprueba el formato, la longitud y los dígitos de control de cada país (fuente). Todos los IBAN etiquetados superan la validación, así que omite 0, pero un estudiante que escribe mal un dígito introduce un valor que el reconocedor rechaza. El reconocedor de teléfonos solo acepta los números que python-phonenumbers considera válidos (fuente), y el generador no siempre escribe números válidos. De los 65 números de teléfono que el detector no encuentra, 63 no son válidos en el país en que vive el estudiante del ticket, así que la mayoría de los fallos con teléfonos son del generador, no del detector.

Regla práctica: Lee los fallos de un detector por casos, no por el total, y lleva una lista de los casos que contiene tu texto. Usa patrones para lo que tiene una forma comprobable, como correos electrónicos, IBAN, números de tarjeta, números de teléfono y fechas, y nunca para nombres o direcciones. Conserva las sumas de control y los planes de numeración, porque son lo que hace precisos a los patrones. Comprueba el patrón de tarjetas con los números de tarjeta que emite tu proveedor de pagos, y los patrones de fechas con las formas en que tus usuarios escriben las fechas.

Compara un modelo de PII

Último cambio en la edición 2026.11.27

Los patrones no tienen nada para nombres ni direcciones, y esos son la mayor parte de los datos personales del texto de la plataforma: 2,455 nombres y 210 direcciones entre los 4,292 tramos etiquetados. Encontrarlos requiere un modelo que lea el contexto, no un modelo general de entidades con nombre. Los autores del conjunto de datos SPY definen PII como las entidades que pueden identificar, contactar o localizar a una persona concreta, y comprobaron que los modelos de entidades con nombre dedicados tienen límites en contextos de PII (Savkin et al., 2025). Usamos un modelo de PII, es decir, uno entrenado para información de identificación personal: Privacy Filter de OpenAI, un modelo con licencia Apache-2.0 y ocho etiquetas fijas, como private_person, private_address y account_number (tarjeta del modelo).

Las etiquetas son las del propio modelo. La tarjeta de OpenAI indica que sus políticas de etiquetado no se pueden configurar mientras el modelo se ejecuta (OpenAI, 2026, sección 4.2). Lo elegimos frente a GLiNER2-PII, el segundo entre los modelos abiertos de PII, por esas etiquetas fijas. GLiNER2-PII recibe en la inferencia las etiquetas que debe buscar, junto con un umbral (tarjeta del modelo), así que una grabación suya tendría que fijar ambas cosas. Privacy Filter tiene 1.5 mil millones de parámetros, de los cuales 50 millones están activos, y se ejecuta en una CPU.

Los ejemplos del libro nunca ejecutan un modelo, así que leen una grabación de su salida. La grabación, data/recorded/pii-entities/, que usan este capítulo y el capítulo 9, contiene cada tramo que el modelo encontró en cada ticket y reseña, con sus desplazamientos, su texto y la etiqueta del modelo. recordings/pii_entities.py la generó en una CPU con el decodificador de referencia del modelo, opf (código), que elige la mejor secuencia de etiquetas para un texto completo, de modo que la mayoría de los tramos salen de una sola pieza en lugar de token a token. Usó el punto de operación por defecto, con los seis sesgos de transición en 0 (archivo de calibración); el modelo también puede configurarse «para una mejor exhaustividad» (sección 2.3.2). El manifiesto fija la revisión del modelo y el SHA-256 de sus pesos, así que cualquiera puede volver a grabarlo y comparar, y lib.pii.recorded rechaza los tramos que no coinciden con el texto en sus desplazamientos. La grabación conserva las etiquetas del modelo, y el ejemplo las asigna a los tipos de la verdad de referencia, así que un mapeo distinto nunca necesita una grabación nueva. Evalúa el modelo, los patrones de la plataforma y ambos juntos, enmascarando lo que encuentre cualquiera de ellos:

privacy-filter-spans.py Python 3.12.15 · duckdb 2.0.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · tldextract 5.4.0 Superado
"""Scores the recorded spans of OpenAI's Privacy Filter against the truth, alone and beside the platform's patterns. Theprose rests on the recall lines for names, addresses, phones and cards, the precision lines, and the texts left withnothing personal."""from lib import pii# Privacy Filter's eight labels, mapped to the truth's entity types. A label the truth has no type for matches nothing.MATCHES = {"private_person": {"PERSON"}, "private_email": {"EMAIL_ADDRESS"}, "private_phone": {"PHONE_NUMBER"},           "private_address": {"LOCATION"}, "account_number": {"CREDIT_CARD", "IBAN_CODE"},           "private_date": {"DATE_TIME"}, "private_url": set(), "secret": set()}model, manifest = pii.recorded("pii-entities")      # the model's spans, from a recording: no model runs hereprint("model:", manifest["model"], "decoded with", manifest["settings"]["decode_mode"])labelled = pii.truth()detectors = {"patterns": pii.find(pii.platform_detector()), "model": model}# both lists joined: a span either one finds is masked, and a span both find is simply counted twicedetectors["both"] = detectors["patterns"] + modelfor name, found in detectors.items():    scores = pii.score(found, labelled, MATCHES)           # Presidio's labels aren't in MATCHES, so match themselves    print(f"{name}, detections: {len(found):,}")    for entity, (n, exact, overlap) in scores.recall.items():        print(f"{name}, {entity}, recall, exact: {exact / n:.2f}")        print(f"{name}, {entity}, recall, overlap: {overlap / n:.2f}")    print(f"{name}, precision, exact: {pii.precision_overall(scores):.2f}")    print(f"{name}, texts with every labelled span masked: {scores.masked:,} of {scores.texts:,}")# Precision by the model's own label: a label that's right for one truth type can still be wrong for anotherfor label, (n, exact, overlap) in pii.score(model, labelled, MATCHES).precision.items():    print(f"model, {label}, detections: {n:,}")    print(f"model, {label}, precision, exact: {exact / n:.2f}")    print(f"model, {label}, precision, overlap: {overlap / n:.2f}")
Salidapython privacy-filter-spans.py
model: openai/privacy-filter decoded with viterbi
patterns, detections: 1,539
patterns, CREDIT_CARD, recall, exact: 0.71
patterns, CREDIT_CARD, recall, overlap: 0.71
patterns, DATE_TIME, recall, exact: 1.00
patterns, DATE_TIME, recall, overlap: 1.00
patterns, EMAIL_ADDRESS, recall, exact: 1.00
patterns, EMAIL_ADDRESS, recall, overlap: 1.00
patterns, IBAN_CODE, recall, exact: 1.00
patterns, IBAN_CODE, recall, overlap: 1.00
patterns, LOCATION, recall, exact: 0.00
patterns, LOCATION, recall, overlap: 0.00
patterns, PERSON, recall, exact: 0.00
patterns, PERSON, recall, overlap: 0.00
patterns, PHONE_NUMBER, recall, exact: 0.84
patterns, PHONE_NUMBER, recall, overlap: 0.85
patterns, precision, exact: 0.97
patterns, texts with every labelled span masked: 405 of 2,586
model, detections: 4,424
model, CREDIT_CARD, recall, exact: 0.69
model, CREDIT_CARD, recall, overlap: 0.69
model, DATE_TIME, recall, exact: 0.97
model, DATE_TIME, recall, overlap: 0.97
model, EMAIL_ADDRESS, recall, exact: 1.00
model, EMAIL_ADDRESS, recall, overlap: 1.00
model, IBAN_CODE, recall, exact: 0.99
model, IBAN_CODE, recall, overlap: 1.00
model, LOCATION, recall, exact: 0.67
model, LOCATION, recall, overlap: 0.79
model, PERSON, recall, exact: 0.84
model, PERSON, recall, overlap: 0.84
model, PHONE_NUMBER, recall, exact: 0.94
model, PHONE_NUMBER, recall, overlap: 0.94
model, precision, exact: 0.84
model, texts with every labelled span masked: 2,095 of 2,586
both, detections: 5,963
both, CREDIT_CARD, recall, exact: 0.92
both, CREDIT_CARD, recall, overlap: 0.92
both, DATE_TIME, recall, exact: 1.00
both, DATE_TIME, recall, overlap: 1.00
both, EMAIL_ADDRESS, recall, exact: 1.00
both, EMAIL_ADDRESS, recall, overlap: 1.00
both, IBAN_CODE, recall, exact: 1.00
both, IBAN_CODE, recall, overlap: 1.00
both, LOCATION, recall, exact: 0.67
both, LOCATION, recall, overlap: 0.79
both, PERSON, recall, exact: 0.84
both, PERSON, recall, overlap: 0.84
both, PHONE_NUMBER, recall, exact: 0.99
both, PHONE_NUMBER, recall, overlap: 0.99
both, precision, exact: 0.88
both, texts with every labelled span masked: 2,120 of 2,586
model, account_number, detections: 746
model, account_number, precision, exact: 0.51
model, account_number, precision, overlap: 0.51
model, private_address, detections: 177
model, private_address, precision, exact: 0.79
model, private_address, precision, overlap: 1.00
model, private_date, detections: 384
model, private_date, precision, exact: 0.50
model, private_date, precision, overlap: 0.50
model, private_email, detections: 543
model, private_email, precision, exact: 1.00
model, private_email, precision, overlap: 1.00
model, private_person, detections: 2,110
model, private_person, precision, exact: 0.98
model, private_person, precision, overlap: 0.98
model, private_phone, detections: 464
model, private_phone, precision, exact: 0.89
model, private_phone, precision, overlap: 0.89
Medida Patrones Modelo Ambos
Exhaustividad, exacta, PERSON 0.00 0.84 0.84
Exhaustividad, exacta, LOCATION 0.00 0.67 0.67
Exhaustividad, exacta, PHONE_NUMBER 0.84 0.94 0.99
Exhaustividad, exacta, CREDIT_CARD 0.71 0.69 0.92
Exhaustividad, exacta, IBAN_CODE 1.00 0.99 1.00
Precisión, exacta 0.97 0.84 0.88
Textos enmascarados por completo 405 of 2,586 2,095 of 2,586 2,120 of 2,586

El modelo encuentra la mayoría de los nombres y direcciones que los patrones no pueden detectar, y los dos detectores se complementan en los números de tarjeta. El modelo y los patrones encuentran aproximadamente la misma proporción de tarjetas, 0.69 y 0.71, pero no las mismas tarjetas, así que juntos encuentran 0.92. Una sección posterior muestra por qué la proporción del modelo es baja.

El modelo paga con precisión, 0.84 en total, y solo 0.51 para account_number y 0.50 para private_date. Eso mide en parte una diferencia en la política de etiquetado. La verdad de referencia deja sin etiquetar los números de factura y las fechas de un problema, y la tarjeta de OpenAI indica que las políticas de etiquetado adecuadas pueden diferir (sección 4.2).

Juntos, los dos detectores dejan 2,120 of 2,586 textos sin nada personal sin enmascarar, frente a 405 of 2,586 con los patrones solos.

Lee los fallos del modelo

Último cambio en la edición 2026.11.27

La ficha de OpenAI indica dónde falla el modelo: no detecta nombres poco frecuentes, nombres de otras tradiciones de nombres, iniciales, nombres acompañados de títulos e identificadores propios de un dominio, y enmascara en exceso entidades públicas, lugares y sustantivos comunes cuando el contexto local no está claro (OpenAI, 2026, sección 4.3). Compara esa lista con los casos difíciles que incluyen los tickets:

privacy-filter-hard-cases.py Python 3.12.15 · duckdb 2.0.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · tldextract 5.4.0 Superado
"""Counts how many of each hard case the model's recorded spans catch, and reads the names it misses by case and length.The prose rests on the missed-name counts and on the first lowercase ticket that both detectors miss."""from collections import Counterfrom lib import piimodel, _ = pii.recorded("pii-entities")labelled = pii.truth()cases = pii.hard_cases(labelled)for case, spans in cases.items():    print(f"{case}, labelled: {len(spans)}")    print(f"{case}, caught by the model: {pii.caught(spans, model)}")for kind, spans in pii.lookalikes().items():    print(f"{kind}, flagged by the model: {pii.caught(spans, model)}")# The names the model misses, by case: read them before trusting a recall figure.missed = pii.missed([s for s in labelled if s.entity == "PERSON"], model, {"private_person"})print("names the model misses:", len(missed))for case in ("first names that are words", "instructors named in reviews"):    often = Counter(pii.text_of(s) for s in pii.missed(cases[case], model, {"private_person"})).most_common(3)    print(f"{case}, missed most often:", ", ".join(name for name, _ in often))# A first name on its own says less than a full name: how many of the misses are one word?print("missed names that are one word:", sum(len(pii.text_of(s).split()) == 1 for s in missed))print("missed names of two words or more:", sum(len(pii.text_of(s).split()) > 1 for s in missed))# islower() counts only names typed entirely in lowercase, so a name with a capital letter, such as "Jane", doesn't.print("of them, typed in lowercase:", sum(len(pii.text_of(s).split()) > 1 and pii.text_of(s).islower() for s in missed))# A lowercase name that neither the model nor the platform's patterns cover any part of, in the first ticket with one.# The model's spans and the patterns' together: a name is missed only when both miss it. The lowest ticket ID is taken,# so the same ticket is printed on every run.first = min(pii.missed(cases["names in lowercase"], model + pii.find(pii.platform_detector())), key=lambda s: s.row_id)print("first ticket with a lowercase name both detectors miss:", first.row_id)print("the name, as typed:", pii.text_of(first))
Salidapython privacy-filter-hard-cases.py
names in lowercase, labelled: 211
names in lowercase, caught by the model: 167
initial and surname, labelled: 163
initial and surname, caught by the model: 162
first names that are words, labelled: 187
first names that are words, caught by the model: 128
instructors named in reviews, labelled: 798
instructors named in reviews, caught by the model: 535
phones typed as digits only, labelled: 257
phones typed as digits only, caught by the model: 256
invoice numbers, flagged by the model: 224
order numbers, flagged by the model: 125
dates of a problem, flagged by the model: 188
names the model misses: 387
first names that are words, missed most often: Summer, Will, Hope
instructors named in reviews, missed most often: Marie, Lori, Augustin
missed names that are one word: 337
missed names of two words or more: 50
of them, typed in lowercase: 43
first ticket with a lowercase name both detectors miss: 19
the name, as typed: juan fonseca

Los fallos son nombres de pila que también son palabras, y el nombre de pila de un instructor, solo, en una reseña. El modelo detecta 128 de los 187 nombres de pila que son palabras, y 535 de los 798 nombres de instructores.

Las iniciales no son el problema: el modelo detecta 162 de 163 iniciales con apellido, y los nombres en minúsculas se detectan en su mayoría, 167 de 211.

Lo que más a menudo se le escapa son las palabras Summer, Will, Hope y los nombres de instructores Marie, Lori, Augustin. El modelo también marca muchos más elementos parecidos que los patrones ajustados: 224 números de factura, 125 números de pedido y 188 fechas de un problema, frente a 31, 0 y 0.

Lo grave de los fallos depende de su longitud. De los 387 nombres que el modelo no detecta, 337 son una sola palabra, un nombre de pila solo, y 50 son más largos, 43 de ellos escritos en minúsculas. Los autores del Text Anonymization Benchmark establecen la misma distinción: no detectar un identificador directo, como un nombre completo, es mucho más perjudicial que no detectar un cuasi-identificador (Pilán et al., 2022). Un nombre de pila solo sigue necesitando enmascararse, ya que una reseña lleva el ID de su alumno, y el nombre de pila de un instructor en una reseña de su propio curso apunta a una sola persona.

La ficha recomienda probar el modelo en tu propio dominio frente a las referencias de la política local antes de usarlo en producción (sección 4.5). También incluye la educación entre los contextos que requieren precauciones adicionales (sección 4.4), y describe el modelo como "un apoyo para la redacción y la minimización de datos, no una garantía de anonimización, cumplimiento o seguridad" (sección 4.1).

Regla práctica: Enmascara el texto libre con un modelo de PII y con los patrones ajustados a la vez, sea lo que sea que encuentre cada uno: el modelo para nombres y direcciones, y las sumas de control de los patrones para números de tarjeta e IBAN. Registra la salida del modelo junto con su revisión, sus pesos y su punto de operación fijados, conserva sus propias etiquetas y asígnalas en el código. Mídelo con tu propio texto, caso difícil por caso difícil, antes de usarlo y después de cada cambio del modelo; si deja pasar demasiado, prueba un punto de operación que favorezca la exhaustividad y vuelve a registrarlo. Trate el texto enmascarado como un texto reducido, nunca como anónimo.

Cuantifica el costo de una etiqueta errónea

Último cambio en la edición 2026.11.27

La comparación con los patrones evaluó el modelo mediante coincidencia exacta y por solapamiento, que ambas requieren una etiqueta del tipo del fragmento. El enmascaramiento no lee la etiqueta: un número de tarjeta que el modelo etiqueta como private_phone sigue ocultándose. La clasificación sí la lee, porque governance/pii.toml asigna cada tipo de entidad a una clasificación: un número de teléfono a personal, un número de tarjeta a sensitive. Mide la cobertura del modelo junto a su exhaustividad, y las etiquetas que da a los números de tarjeta, los números de teléfono y las direcciones de la plataforma:

privacy-filter-labels.py Python 3.12.15 · duckdb 2.0.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · tldextract 5.4.0 Superado
"""Measures the model's coverage of card numbers, phone numbers and addresses whatever their label, and counts the labelsthat would misclassify them. The prose rests on the coverage lines, the mislabelled counts and the uncovered addresses."""from lib import pii# What the model's labels cost. A span is covered when every character of it is inside some detection, whatever its# label: that's what masking needs. Exact and overlap matching also need a label of the span's type.model, _ = pii.recorded("pii-entities")labelled = pii.truth()covered = pii.coverage(model, labelled)for entity in ("CREDIT_CARD", "PHONE_NUMBER", "LOCATION"):    n, fully = covered[entity]    print(f"{entity}, covered by the model, any label: {fully / n:.2f}")spans = {entity: [s for s in labelled if s.entity == entity] for entity in ("CREDIT_CARD", "PHONE_NUMBER", "LOCATION")}print("card numbers labelled private_phone:", pii.caught(spans["CREDIT_CARD"], model, {"private_phone"}))print("phone numbers labelled account_number:", pii.caught(spans["PHONE_NUMBER"], model, {"account_number"}))# For each address, the labels of the detections that overlap it, and the characters no detection covers.on = pii.labels_on(spans["LOCATION"], model)print("addresses with no detection at all:", sum(not labels for labels in on))print("addresses read, at least in part, as a person:", sum("private_person" in labels for labels in on))# A person label and no address label: the address was read as a name, which overlap matching can't credit.print("of them, with no address label:", sum({"private_person"} <= labels and "private_address" not in labels for labels in on))left = [pii.uncovered(address, model) for address in spans["LOCATION"]]print("addresses not fully covered:", sum(bool(chars) for chars in left))print("of them, with only spaces and punctuation left:", sum(bool(chars) and not any(c.isalnum() for c in chars) for chars in left))
Salidapython privacy-filter-labels.py
CREDIT_CARD, covered by the model, any label: 0.87
PHONE_NUMBER, covered by the model, any label: 1.00
LOCATION, covered by the model, any label: 0.67
card numbers labelled private_phone: 40
phone numbers labelled account_number: 27
addresses with no detection at all: 24
addresses read, at least in part, as a person: 28
of them, with no address label: 20
addresses not fully covered: 70
of them, with only spaces and punctuation left: 21

Una etiqueta errónea cuesta más a la clasificación que al enmascaramiento. El modelo cubre 0.87 de los números de tarjeta, pero etiqueta 40 de los 213 como números de teléfono, así que su exhaustividad para tarjetas es solo de 0.69. Si la plataforma clasificara las columnas según las etiquetas del modelo, una columna con esos números de tarjeta se propondría como personal, no como sensitive. Eso es lo que aportan los patrones: su comprobación de Luhn mantiene como tarjetas los números etiquetados como tales.

El error también va en el otro sentido, hacia el lado más estricto. El modelo etiqueta 27 números de teléfono como account_number, que se asigna a números de tarjeta e IBAN, así que su cobertura de teléfonos es de 1.00 y su exhaustividad, 0.94.

Las direcciones muestran qué mide cada métrica. La exhaustividad exacta del modelo para ellas es de 0.67 y su exhaustividad por solapamiento, de 0.79, y su cobertura es de 0.67. El modelo no encuentra nada en 24 direcciones.

El modelo lee parte de 28 direcciones como si fueran una persona, ya que Faker construye muchos nombres de calle a partir de apellidos, como señala la ficha de datos de la plataforma. Asigna a 20 de ellas ninguna etiqueta de dirección, así que la coincidencia por solapamiento también las pierde. Otras direcciones llegan en fragmentos con la etiqueta correcta, como una calle y una localidad separadas por una coma. La coincidencia por solapamiento las acredita, pero la cobertura no. De las 70 direcciones que no están cubiertas por completo, 21 tienen enmascaradas todas las letras y cifras, y solo queda una coma o un espacio. La cobertura es la medida que necesita el enmascaramiento, y es estricta.

Regla práctica: Informa de la cobertura, con cualquier etiqueta, junto a la exhaustividad con la etiqueta correcta: el enmascaramiento necesita la primera, y la clasificación, la segunda. Lee qué etiquetas asigna un detector a cada tipo de fragmento, y mantén un reconocedor con una comprobación de suma de control para cada identificador cuya etiqueta determine una clasificación, como los números de tarjeta.

Clasifica de nuevo cuando cambie el esquema

Último cambio en la edición 2026.11.27

Una clasificación describe una columna en un momento dado, y el capítulo 2 mostró cómo los esquemas cambian con el tiempo. Por eso la pregunta es cuándo volver a clasificar, y no en cada ID de esquema: en PyIceberg, editar la descripción de una columna genera un nuevo ID de esquema sin que aparezca una columna nueva. Lo que hay que clasificar es un ID de campo, el número que Iceberg asigna a cada columna, que los metadatos nunca han visto. Iceberg asigna un ID nuevo a cada columna añadida, y una columna renombrada conserva su ID y, con él, su clasificación revisada. Los valores también pueden cambiar sin que cambie el esquema, así que las muestras de columnas de texto también deben volver a ejecutarse según un calendario. Algunos proveedores ofrecen esto como servicio: Databricks afirma que su clasificación se realiza de forma incremental y clasifica los datos nuevos sin configuración manual (documentación de Databricks), una afirmación que no probamos.

El equipo de soporte necesita un número al que llamar a los estudiantes para los tickets abiertos por teléfono, así que añade una columna llamada callback_number a support.tickets. El cambio se produce en cuatro pasos: editar una descripción, añadir la columna, rellenarla con los números de teléfono de los estudiantes y, después, clasificar solo los ID de campo que governance/metadata.toml no tiene:

reclassify-new-columns.py Python 3.12.15 · duckdb 2.0.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · tldextract 5.4.0 Superado
"""Edits the tickets table twice, first a column's description and then a new column, and after each change counts the fieldIDs the metadata lacks. The prose rests on the schema IDs, the field counts and the proposal for the new column."""from pyiceberg.types import StringTypefrom lib import metadata, piifrom lib.catalog import fill_column, open_catalogfrom lib.platform import loadfrom lib.warehouse import connectcatalog = open_catalog(["support.tickets"])tickets = catalog.load_table("support.tickets")reviewed = metadata.load()["support.tickets"].columns           # field ID -> the column as people reviewed it# A field ID the reviewed metadata doesn't have: Iceberg gives each added column a new one.unclassified = lambda: {f.field_id for f in tickets.schema().fields if f.field_id not in reviewed}print("schema ID at the start:", tickets.schema().schema_id)with tickets.update_schema() as update:                         # a doc edit: a new schema, no new column    update.update_column("body", doc="What the learner wrote, as they wrote it.")print("schema ID after a doc edit:", tickets.schema().schema_id)print("fields to classify after the doc edit:", len(unclassified()))# The support team starts storing the number to call back for tickets opened by phone: the learner's phone number.with tickets.update_schema() as update:    update.add_column("callback_number", StringType(), doc="Where to call the learner back.")phone_of = {row["learner_id"]: row["phone"] for row in load("crm.learners").to_pylist()}# tickets from other channels have no callback number, so their value is Nonefill_column(tickets, "callback_number", lambda row: phone_of[row["learner_id"]] if row["channel"] == "phone" else None)print("schema ID after adding a column:", tickets.schema().schema_id)print("fields to classify after adding a column:", len(unclassified()))# only= keeps the proposals to the field IDs the metadata lacks.for f in pii.classify(catalog, connect(catalog), pii.platform_detector(), only={"support.tickets": unclassified()}):    found = ", ".join(f"{entity} in {n} of {f.sampled}" for entity, n in f.found.items())    print(f"{f.table}.{f.column}, field ID: {f.field_id}")    print(f"{f.table}.{f.column}, entity its name suggests: {f.named}")    print(f"{f.table}.{f.column}, found in its sampled values: {found}")    print(f"{f.table}.{f.column}, proposed classification: {f.classification}")
Salidapython reclassify-new-columns.py
schema ID at the start: 0
schema ID after a doc edit: 1
fields to classify after the doc edit: 0
schema ID after adding a column: 2
fields to classify after adding a column: 1
support.tickets.callback_number, field ID: 9
support.tickets.callback_number, entity its name suggests: None
support.tickets.callback_number, found in its sampled values: PHONE_NUMBER in 154 of 173
support.tickets.callback_number, proposed classification: personal

Una edición de documentación traslada el esquema a un nuevo ID y deja 0 campos por clasificar, ya que no añade ninguna columna. Al añadir la columna, el esquema pasa a 2, con 1 campo por clasificar: el campo 9.

Ninguna regla basada en nombres coincide con callback_number, porque su nombre no contiene ninguna de las palabras que busca la regla de teléfono, y así es como una regla de nombres pasa por alto una columna para la que nadie la diseñó. Sus valores lo resuelven. La muestra encuentra PHONE_NUMBER in 154 of 173, y la propuesta es personal.

La solicitud de cambios que añade la columna es el lugar donde debe ir su clasificación, junto a la entrada de metadatos que necesita: el capítulo 10 hace fallar esa solicitud de cambios hasta que la columna tenga una clasificación. Una propuesta basada en valores necesita una columna que contenga valores, así que esta procede de la muestra programada.

Regla práctica: Clasifica todo ID de campo que los metadatos no tengan, en la solicitud de cambios que lo añade, y no permitas que se fusione sin una clasificación revisada. Basa el disparador en los ID de campo, nunca en los ID de esquema. Vuelve a muestrear también todas las columnas de texto según un calendario, porque los valores cambian sin que cambie el esquema.

Qué sale mal en producción

Último cambio en la edición 2026.11.27

El peor fallo de un detector es no detectar algo, y su salida siempre parece una lista de hallazgos: lo que omite nunca aparece en ella:

  • Números de teléfono leídos como números bancarios. Con los valores por defecto de Presidio, toda secuencia de 8 a 17 dígitos es un número bancario de EE. UU., y también lo es todo número de teléfono escrito sin separadores. Las pruebas de la tabla de tickets lista 689 números bancarios que no existen, un informe de "números bancarios en tickets" lleva a alguien al equipo equivocado, y asignar esa entidad a una clasificación crearía columnas por la razón equivocada. Conserva solo los reconocedores que necesite tu texto, cada uno con su propio umbral, como hace la sección de ajuste, y cuenta las detecciones por etiqueta: una etiqueta con cientos de aciertos y ningún tramo etiquetado es un falso positivo.
  • Nombres en texto libre que no se detectan. Los patrones no encuentran nombres, y el modelo omite algunos nombres en minúscula, nombres de pila que también son palabras y nombres de pila que aparecen solos. El ticket 19 sigue diciendo "soy juan fonseca, todavía no puedo iniciar sesión" después de que ambos detectores hayan actuado, y supera todas las comprobaciones que cuentan detecciones. Solo lo notas al medir la exhaustividad frente a texto etiquetado, caso difícil por caso difícil, y al leer una muestra de la salida enmascarada.
  • Datos personales en una columna llamada notes. Ninguna regla de nombres la marca, y un revisor que nunca la leyó la clasifica como internal. Muestrea los valores de cada columna de texto y trata las columnas de texto libre como personales hasta que una muestra demuestre lo contrario.
  • Una columna más sensible que sus metadatos. Las personas que aprenden pegan números de tarjeta en los tickets, así que support.tickets.body contiene datos sensitive bajo una clasificación personal. Compara cada propuesta con los metadatos revisados y envía una más estricta al responsable de la tabla.
  • Un detector que accede a la red. AnalyzerEngine() descarga un modelo, y tldextract obtiene la Public Suffix List. Sin conexión, la canalización falla; con conexión, el mismo texto puede clasificarse de forma distinta en dos máquinas. Un ajuste leído al importar solo se mantiene si se hace antes de que algo importe la biblioteca. Configura el motor, fija lo que descargaría, comprueba que el ajuste se aplicó y ejecuta las pruebas del detector con la red desactivada.
  • Una verdad moldeada por su generador. El texto de la plataforma proviene de 30 plantillas de frases rellenadas con Faker, que escribe cada fecha de nacimiento de una sola forma, números de teléfono que no son válidos en el lugar donde vive la persona que aprende, y nombres de calle construidos a partir de nombres de personas. Lee los fallos antes de confiar en una cifra de exhaustividad, y vuelve a medir sobre muestras etiquetadas de tu propio texto.

Lo que decidió este capítulo

Último cambio en la edición 2026.11.27
  • Las columnas se clasifican según su nombre, su tipo y sus valores. Las reglas de nombre se aplican a cada columna; las columnas de texto se muestrean; prevalece la evidencia más estricta, con internal como mínimo, y solo una persona puede asignar public.
  • Las muestras son reproducibles: 200 valores no nulos por columna de texto, mediante un muestreo de depósito (reservoir) con semilla en un único hilo de DuckDB.
  • Presidio se ejecuta sin conexión, sobre NoOpNlpEngine, con 6 reconocedores, cada uno con su propio umbral; las regiones telefónicas se leen de los países de las personas que aprenden, y tldextract usa su propia copia de la Public Suffix List, que se comprueba al cargar lib.pii.
  • Los detectores se miden frente a tramos etiquetados: la exhaustividad (recall) por tipo de entidad, con coincidencia exacta y por solapamiento, con una etiqueta del tipo correcto; la cobertura, sea cual sea la etiqueta; la precisión por etiqueta y los textos que quedan sin datos personales, dando prioridad a la exhaustividad.
  • Una propuesta más estricta que los metadatos es un hallazgo: support.tickets.body pasa a team-support como sensitive, y billing.payments.card_number a team-billing, junto con la evidencia de que contiene números de tarjeta completos.
  • El texto libre se enmascara con dos detectores: el Privacy Filter de OpenAI, registrado en una revisión y un punto de operación fijados, para nombres y direcciones, y los patrones ajustados para números de tarjeta, IBAN y números de teléfono, cuyas sumas de comprobación permiten etiquetar los números de tarjeta como tarjetas. El enmascaramiento oculta todo lo que cualquiera de los dos encuentre; ninguno de los dos se considera fiable para hacer anónimo un texto.
  • Ningún ejemplo muestra un número de teléfono, de tarjeta o IBAN completo: lib.pii.masked conserva los últimos cuatro dígitos.
  • La reclasificación sigue a los identificadores de campo: cada campo que los metadatos no tienen se clasifica en la solicitud de cambios que lo añade, y las columnas de texto se vuelven a muestrear según un calendario. Un detector es tan bueno como la medición en la que se apoya, y lo que no detecta nunca aparece en su resultado. La medición es lo que indica a un equipo cuáles de sus clasificaciones puede dar por buenas y cuáles tiene que comprobar a mano.

Este capítulo, en esta edición

Edición 2026.11.31Ejemplos verificados el 19 de nov de 2026Superan la prueba 11 de 11 ejemplos ejemplos de este capítulo

Traducido del libro en inglés, edición 2026.11.31.

Cita esta sección

Formato

Cada formato cita el libro en inglés, que esta traducción sigue.

Cada formato nombra esta edición. Su enlace abre la edición actual, donde el encabezado de cada sección indica cuándo cambió su texto por última vez. Las fechas de acceso y de recuperación son el día en que lo abres.

En esta página

Capítulo 3 de 10: Encontrar datos personales

  1. Clasifica las columnas a partir del esquema
  2. Ejecutar Presidio sin conexión
  3. Muestrea los valores de una columna de la misma forma en cada ejecución
  4. Clasificar columnas a partir de sus valores
  5. Medir un detector contra spans etiquetados
  6. Ajusta los reconocedores frente a la verdad
  7. Detecta dónde fallan los patrones
  8. Compara un modelo de PII
  9. Lee los fallos del modelo
  10. Cuantifica el costo de una etiqueta errónea
  11. Clasifica de nuevo cuando cambie el esquema
  12. Qué sale mal en producción
  13. Lo que decidió este capítulo

Volver arribaTodos los capítulos