Gobernar los datos para IA

Unos 39 minutos de lectura, con 10 ejemplos en 12 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 construir los datos de los que aprende un asistente de IA bajo las mismas reglas que cualquier otra lectura de tu plataforma. Admitirás solo los registros cuyos autores aceptaron ese uso, reemplazarás sus datos personales por seudónimos y medirás lo que el detector no encontró, eliminarás los duplicados encontrados con MinHash, conservarás junto a cada registro su origen, y harás que el pipeline escriba y verifique una ficha del conjunto de datos en cada ejecución. También podrás citar lo que dice la Ley de IA de la UE sobre los datos de entrenamiento.

La plataforma, la plataforma de aprendizaje en línea que sigue este libro, quiere un asistente de cursos que responda a partir de lo que escriben los estudiantes en sus reseñas. Planea basar primero el asistente en ese texto y, más adelante, ajustarlo con el mismo texto. review_corpus, uno de los cuatro pipelines SQL de los que el capítulo 4 captura el linaje, copia cada fila de learning.reviews en ai.review_corpus, con el curso y la calificación de cada reseña. El capítulo 2 descubrió que ai.review_corpus no tiene propietario ni clasificación, y la copia tiene cuatro problemas más. Contiene todas las reseñas, lo autoricen o no sus autores para que su texto entrene una IA. Su texto contiene nombres y correos electrónicos, que el capítulo 3 encontró en las reseñas. La mayoría de sus reseñas se repiten unas a otras. Y nada en ella indica de dónde procede cada registro, así que nadie puede demostrar que una reseña fue admitida, ni localizarla de nuevo cuando su autor cambia de opinión.

Este capítulo rehace el trabajo con el módulo compartido del libro para datos de IA, lib.ai_data, y el asistente aprende solo de esa compilación gobernada: pipelines/review_corpus.sql se mantiene como la copia no gobernada del capítulo 4, para que CI siga verificando su linaje. El módulo ejecuta el SQL propio del pipeline a través de la capa de cumplimiento que construyó el capítulo 6, reemplaza los datos personales que quedan en el texto, elimina duplicados y escribe el corpus, su linaje y su ficha del conjunto de datos. Sus ajustes están en governance/ai_data.toml, revisados como una política, y lo mismo ocurre con las respuestas que el código necesita a preguntas legales, cada una un marcador que el equipo jurídico de la plataforma reemplaza por su respuesta y su motivo.

Admite solo reseñas cuyos autores dieron su consentimiento

Último cambio en la edición 2026.11.27

En la plataforma, el consentimiento para un uso no cubre otro, porque la pregunta que responde un estudiante nombra el uso. El artículo 5(1)(b) del Reglamento General de Protección de Datos (RGPD) de la UE dice que los datos personales serán "recogidos con fines determinados, explícitos y legítimos, y no serán tratados ulteriormente de manera incompatible con dichos fines" (RGPD). El código lee la respuesta registrada a si entrenar una IA está cubierto desde [legal.consent] en governance/ai_data.toml, y decide el consentimiento registro a registro cuando se construye el corpus, no a partir del alta de la cuenta ni una sola vez para toda la tabla.

crm.learners.ai_training_consent registra si un estudiante aceptó que su texto entrene la IA de la plataforma. El capítulo 5 lo convirtió en un atributo que la política de acceso lee, de modo que una lectura de learning.reviews para el propósito ai-training conserva solo las reseñas cuya respuesta del autor es verdadera, con los datos de contacto eliminados. lib.ai_data.read ejecuta el SELECT de pipelines/review_corpus.sql a través de la capa de cumplimiento como analyst-1, el principal de ciencia de datos, indicando el propósito. lib.ai_data.build se niega a ejecutarse a menos que la capa filtre por la columna que nombra la respuesta de consentimiento. Compara tres construcciones: la canalización simple, pipelines/review_corpus.sql ejecutada tal como está escrita; la lectura gobernada; y un filtro de consentimiento escrito a mano.

Copiada tal como está, la canalización simple pondría 120 correos etiquetados y 798 nombres etiquetados en el corpus, a partir de 3,000 reseñas.

La lectura gobernada conserva 436 reseñas, las de los autores que dijeron que sí. Sin propósito, el mismo principal obtiene 3,000 reseñas, 0 de ellas con su texto, así que un trabajo que olvida indicar su propósito no obtiene nada con lo que pueda entrenar.

Fíjate en que el filtro escrito a mano parece respetar el consentimiento, por eso es el que hay que reconocer: deja fuera a los estudiantes que dijeron que no. Conserva 2,045 reseñas, y 1,609 de ellas, 79%, son de estudiantes a quienes nunca se les preguntó. El README de los datos generados por la plataforma dice que el consentimiento es desconocido para los registros anteriores al 1 de junio de 2025, y todo estudiante sin respuesta se registró desde Jan 1, 2024 to May 31, 2025. Una respuesta desconocida no es un sí. Un corpus construido con ese filtro estaría compuesto mayormente por texto que ningún consentimiento cubre, y nada en él parecería incorrecto: ningún error, un número de filas verosímil y una condición sobre la columna de consentimiento que un revisor leería como correcta. El filtro de la capa de cumplimiento prueba IS TRUE, de modo que una respuesta desconocida cuenta como no, algo que el capítulo 6 construyó precisamente para este caso.

En la plataforma, cada reseña se escribió bajo un mismo conjunto de condiciones, así que la ficha indica una sola licencia, leída desde [legal.licence]. Un corpus que mezcla fuentes, como reseñas y publicaciones de foros, necesita también una licencia por registro, lo que es una de las razones por las que cada registro conserva su tabla de origen.

Regla práctica: Decide el consentimiento registro a registro, al construir el corpus, a partir de la respuesta que tu equipo jurídico indique que cubre el uso, y admite solo los registros cuya respuesta sea sí: nunca filtres los rechazos para conservar el resto. Construye el corpus a través de la capa de cumplimiento con su propósito indicado, y haz que la construcción compruebe que la capa filtra por esa respuesta. Guarda las respuestas del equipo jurídico, con sus motivos, en un archivo revisado que el código lea, y lleva las licencias por registro cuando una fuente mezcle varias.

Reemplaza los datos personales del texto y mide lo que queda

Último cambio en la edición 2026.11.27

El consentimiento decide de quién puede entrar un texto en el corpus. No hace que el texto esté libre de datos personales: una reseña nombra a su instructor, o da el correo electrónico de su autor para preguntas. Antes de que un texto así entrene o fundamente un modelo, el trabajo del corpus detecta los datos personales que contiene, reemplaza cada valor y mide lo que queda, porque la salida de un detector enumera lo que encontró y nunca lo que se le escapó. La verdad, los tramos etiquetados del capítulo 3, marca cada dato personal que el generador colocó en las reseñas. lib.ai_data.left cuenta cuántos valores etiquetados siguen en el texto después de un paso, comparando por valor, ya que cada reemplazo desplaza las posiciones que vienen después.

Las reseñas llegan desde la capa de cumplimiento con su máscara redact_contacts aplicada, que sustituye los correos electrónicos y los números de teléfono por [email] y [phone] (capítulo 6). El detector del capítulo 3, lib.pii.platform_detector, ejecuta los reconocedores de patrones de Presidio sin ningún modelo de lenguaje, y ningún patrón encuentra un nombre. Por eso lib.ai_data.detector añade una lista de denegación de Presidio con los nombres que conoce la plataforma: cada palabra del nombre de cada instructor, que Presidio escapa y compara como palabra completa, sin distinguir mayúsculas salvo que se indique lo contrario (reconocedor de patrones de Presidio). La lista proviene de crm.instructors, que analyst-1 no puede leer. Así que el trabajo propio del equipo de la plataforma, nombrado en [names] dentro de governance/ai_data.toml, la construye con el acceso de la plataforma, igual que la capa de cumplimiento lee crm.learners para el consentimiento, y entrega al trabajo del corpus la lista, nunca la tabla. La ficha registra qué trabajo la construyó y cuántas palabras contiene. lib.ai_data.known_names representa ese trabajo. Cada valor encontrado se convierte en un seudónimo con clave, que la sección siguiente construye. Mide cada paso sobre las reseñas que lee el corpus, y después prueba una lista más larga, que incluya además el nombre de cada alumno:

corpus-personal-data-left.py Python 3.12.15 · datasketch 2.0.0 · duckdb 2.0.0 · mlcroissant 1.1.1 · openlineage-python 1.55.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · presidio-anonymizer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · regopy 1.5.2 · sqlglot 30.33.0 · tldextract 5.4.0 Superado
"""Counts the labelled names and emails still in the reviews after each step of the corpus job, and the false positives of the instructors' list and of a longer one. The prose's point rests on the "then the instructors' names, PERSON left" line and the false-positive lines."""from lib import ai_data, piifrom lib.catalog import open_catalogfrom lib.enforce import Enforcer# The reviews the corpus job reads: consenting authors only, with emails and phone numbers already masked.rows = ai_data.read(Enforcer(open_catalog(["crm.learners", "learning.courses", "learning.reviews"])))texts = {row["review_id"]: row["body"] for row in rows}    # keyed by review ID, to match the labelled values row by row# What's left of the labelled personal data after each step, matched by value against the generator's truth.detectors = {"then the pattern recognizers": pii.platform_detector(), "then the instructors' names": ai_data.detector()}# the texts as the enforcement layer leaves them, before any detector runsstages = {"masked by the enforcement layer": texts}# each detector runs alone on the masked texts; pseudonymize returns the text firststages |= {name: {i: ai_data.pseudonymize(engine, text)[0] for i, text in texts.items()} for name, engine in detectors.items()}for stage, done in stages.items():    for entity, (placed, still) in ai_data.left(done).items():        print(f"{stage}, {entity} left: {still} of {placed}")# the instructors' words, from the governance team's listnames = ai_data.known_names()print("words in the list of instructors' names:", len(names))# short words are the ones ordinary text could containprint("words in the list of 3 characters or fewer:", ", ".join(word for word in names if len(word) <= 3))false_positives = sum(ai_data.unlabelled(ai_data.detector(), texts).values())assert false_positives == 0print("false positives, instructors' names:", false_positives)# Every name the platform holds, learners' too, on the same reviews: in any case, then only as written.# the union of the instructors' words and every learner's, which the table holdslonger = sorted(set(names) | set(ai_data.known_names("crm.learners")))# matched in any case, as the platform's detector matches by defaulteveryone = ai_data.detector(longer)wrong = ai_data.unlabelled(everyone, texts)print("words in the list, with learners' names:", f"{len(longer):,}")print("false positives, with learners' names:", sum(wrong.values()))print("most common false positives:", ", ".join(f"{word} ({n})" for word, n in wrong.most_common(2)))# review 24, which the longer list changesprint("a review after:", ai_data.pseudonymize(everyone, texts[24])[0])# a word matches only as written, so a lowercase word no longer matches a capitalized namecased = ai_data.detector(longer, match_case=True)cased_wrong = sum(ai_data.unlabelled(cased, texts).values())assert cased_wrong == 0print("false positives, with learners' names, matching case:", cased_wrong)# pseudonymize with the cased detector, then count what is left by valueleft = ai_data.left({i: ai_data.pseudonymize(cased, text)[0] for i, text in texts.items()})assert left["PERSON"][1] == 0print("names left, with learners' names, matching case:", f"{left['PERSON'][1]} of {left['PERSON'][0]}")
Salidapython corpus-personal-data-left.py
masked by the enforcement layer, EMAIL_ADDRESS left: 0 of 19
masked by the enforcement layer, PERSON left: 120 of 120
then the pattern recognizers, EMAIL_ADDRESS left: 0 of 19
then the pattern recognizers, PERSON left: 120 of 120
then the instructors' names, EMAIL_ADDRESS left: 0 of 19
then the instructors' names, PERSON left: 0 of 120
words in the list of instructors' names: 106
words in the list of 3 characters or fewer: Ray, Roy, Ulf, Uss, de, la
false positives, instructors' names: 0
words in the list, with learners' names: 4,316
false positives, with learners' names: 147
most common false positives: best (80), date (67)
a review after: Some videos are out of <PERSON_8e2b63a6>.
false positives, with learners' names, matching case: 0
names left, with learners' names, matching case: 0 of 120

La máscara de la capa de cumplimiento deja 0 of 19 correos electrónicos y 120 of 120 nombres, y los reconocedores de patrones dejan 120 of 120 nombres, ya que ningún patrón encuentra un nombre.

Solo la lista de instructores elimina nombres. Con sus nombres añadidos, el detector deja 0 of 120 nombres y no produce falsos positivos, aunque la lista contiene palabras cortas que un texto corriente podría incluir: Ray, Roy, Ulf, Uss, de, la.

La lista más larga, con también el nombre de cada alumno, produce 147 falsos positivos. Los más comunes, best (80), date (67), son apellidos que también son palabras del inglés, y la lista convierte Some videos are out of date. en Some videos are out of <PERSON_8e2b63a6>. en el corpus.

Respetar las mayúsculas y minúsculas al comparar evita ambos problemas. Si la lista se compara tal como está escrita, la lista más larga no produce falsos positivos y no deja nombres, porque en estas reseñas todos los nombres empiezan con mayúscula. Con texto real no detectaría los nombres escritos en minúsculas que el capítulo 3 encontró en los tickets. La plataforma conserva la lista de instructores, comparada sin distinguir mayúsculas: los instructores son las personas de las que hablan las reseñas, y así el trabajo del corpus guarda sus nombres en lugar del nombre de cada alumno.

El resultado de la lista vale solo para estos datos. Los tramos etiquetados son generados, y las reseñas generadas nombran solo a instructores, así que no pueden contener el caso que una lista de instructores no detecta, como el nombre de un compañero de clase. Para los nombres que nadie incluyó, el detector que conviene probar es un modelo de entidades nombradas. El capítulo 3 comparó uno, el Privacy Filter de OpenAI, a partir de un registro de sus detecciones, puntuado contra los tramos etiquetados con lib.pii.score. Puntúalo del mismo modo, sobre las reseñas que lee el corpus:

privacy-filter-on-the-corpus.py Python 3.12.15 · datasketch 2.0.0 · duckdb 2.0.0 · mlcroissant 1.1.1 · openlineage-python 1.55.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · presidio-anonymizer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · regopy 1.5.2 · sqlglot 30.33.0 · tldextract 5.4.0 Superado
"""Scores OpenAI's Privacy Filter, from its recorded detections, against the labelled spans in the reviews the corpus reads. The prose's point rests on the "names the model finds, exactly" and "names the model misses" lines."""from collections import Counterfrom lib import ai_data, piifrom lib.catalog import open_catalogfrom lib.enforce import Enforcer# Privacy Filter's eight labels, mapped to the labelled spans' entity types. A label with no type 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()}# The reviews the corpus job reads, with the model's recorded detections and the labelled spans in them. The model read# each review as written, before the enforcement layer's mask, which changes no name.corpus = {row["review_id"] for row in ai_data.read(Enforcer(open_catalog(["crm.learners", "learning.courses",                                                                          "learning.reviews"])))}# the model's detections as recorded, not a live call to the modelmodel, manifest = pii.recorded("pii-entities")found = [span for span in model if span.source == "reviews" and span.row_id in corpus]labelled = [span for span in pii.truth() if span.source == "reviews" and span.row_id in corpus]print("model:", manifest["model"])print("reviews measured:", len(corpus))# per entity type: [labelled, found exactly, found overlapping], then per detector label: [found, exact, overlapping]scores = pii.score(found, labelled, MATCHES)# the overlap count is unused here: the prose counts exact matches onlyplaced, exact, _ = scores.recall["PERSON"]print("labelled names:", placed)print("names the model finds, exactly:", exact)# private_person is the model's label for a name, so only that label counts as a matchmissed = pii.missed([span for span in labelled if span.entity == "PERSON"], found, {"private_person"})print("names the model misses:", len(missed))often = Counter(map(pii.text_of, missed)).most_common(3)print("names it misses most often:", ", ".join(f"{name} ({n})" for name, n in often))# What the model finds where no labelled span of the type its label maps to is: text it would replace for nothing.wrong = sum(n - overlap for n, _, overlap in scores.precision.values())print("the model's detections:", len(found))print("of them, overlapping no labelled span of their type:", wrong)
Salidapython privacy-filter-on-the-corpus.py
model: openai/privacy-filter
reviews measured: 436
labelled names: 120
names the model finds, exactly: 83
names the model misses: 37
names it misses most often: Marie (4), Liwia (4), Luigi (4)
the model's detections: 102
of them, overlapping no labelled span of their type: 0

En estas reseñas el modelo no puede sustituir a la lista, y estos datos no pueden mostrar qué aporta, ya que cada nombre que contienen está en la lista. Encuentra 83 de los 120 nombres etiquetados con exactitud y se le escapan 37, sobre todo Marie (4), Liwia (4), Luigi (4), mientras que a la lista no se le escapa ninguno.

De sus 102 detecciones, 0 no se superponen con ningún tramo etiquetado de su mismo tipo. Donde el texto nombre a personas que ninguna lista contiene, ejecuta ambos, medidos primero de esta manera.

El texto que sale todavía puede identificar a personas. Un detector se escapa de algunos tramos, el texto puede identificar a alguien sin nombre, y cada registro conserva un ID de reseña que lleva hasta su autor a través de learning.reviews. El considerando 26 del RGPD dice: "Los datos personales sometidos a una seudonimización que pudieran atribuirse a una persona física mediante la utilización de información adicional deben considerarse información sobre una persona física identificable" (RGPD, considerando 26). Por eso llamamos al corpus seudonimizado, nunca anonimizado.

Regla práctica: Detecta los datos personales del texto del corpus después de las máscaras de la capa de cumplimiento, añade los identificadores que tu plataforma guarda sobre las personas de las que trata el texto, y mide lo que queda contra datos etiquetados, por valor, después de cada cambio en el detector. Prefiere una lista corta de los nombres de los que trata tu texto a cada nombre que tengas, ya que una lista larga coincide con palabras corrientes. Haz que construya la lista un trabajo que pueda leer los nombres, y registra qué lista usó cada corpus. Mide un modelo de entidades nombradas de la misma manera antes de confiar en él para nombres que ninguna lista contiene. Mantén la lista fuera del corpus, y llama seudonimizado al resultado.

Mantén los seudónimos consistentes con un hash con clave

Último cambio en la edición 2026.11.27

Un nombre detectado puede reemplazarse por un marcador, <PERSON>, o por un seudónimo: un token para un nombre, el mismo dondequiera que aparezca ese nombre. Las reseñas de la plataforma nombran a un instructor solo por su nombre de pila, y ningún par de instructores comparte nombre de pila, así que aquí un token representa a una persona. Un seudónimo conserva quién es quién, de modo que dos reseñas que elogian al mismo instructor siguen diciéndolo.

El anonimizador de Presidio tiene un operador hash, y desde la versión 2.2.361 sala cada hash de forma aleatoria por defecto, por seguridad (anonimizador de Presidio). Una sal aleatoria hace que cada hash no pueda vincularse con el siguiente, y por tanto que no sirva como seudónimo. Para obtener el mismo hash para el mismo valor, la documentación dice que debes proporcionar explícitamente un parámetro salt, de al menos 128 bits (16 bytes).

El trabajo del corpus usa en cambio su propio hash con clave, mediante el operador custom de Presidio, que recibe una lambda que debe devolver una cadena. lib.ai_data.pseudonym calcula un HMAC con SHA-256 del tipo de entidad y del valor en minúsculas, bajo una clave que solo posee el trabajo del corpus, y conserva ocho dígitos hexadecimales. HMAC es la construcción que describe la RFC 2104 para dar clave a un hash, y uno de sus objetivos declarados es "Disponer de un análisis criptográfico bien conocido de la fortaleza del mecanismo de autenticación, basado en supuestos razonables sobre la función hash subyacente" (RFC 2104). La biblioteca estándar de Python lo incluye, como hmac, así que el trabajo no tiene razón para dar clave a un hash de otra forma.

Dos de las reseñas del corpus nombran al mismo instructor, y reemplazar ese nombre de ambas formas muestra cuál mantiene las dos reseñas vinculadas:

keyed-pseudonyms.py Python 3.12.15 · datasketch 2.0.0 · duckdb 2.0.0 · mlcroissant 1.1.1 · openlineage-python 1.55.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · presidio-anonymizer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · regopy 1.5.2 · sqlglot 30.33.0 · tldextract 5.4.0 Superado
"""Replaces the same instructor's name in two reviews by Presidio's hash, by the corpus's keyed hash and by the enforcement layer's mask. The prose's point rests on the Presidio hash lines and the keyed pseudonym line."""from collections import Counterfrom presidio_anonymizer import AnonymizerEnginefrom presidio_anonymizer.entities import InvalidParamError, OperatorConfigfrom sqlglot import expfrom lib import ai_data, enforcefrom lib.catalog import open_catalogfrom lib.enforce import Enforcerfrom lib.platform import load# Two of the corpus's reviews that name the same instructor, with what the detector found in each.layer = Enforcer(open_catalog(["crm.learners", "learning.courses", "learning.reviews"]))engine = ai_data.detector()found = [(row["body"], engine.analyze(row["body"], language="en")) for row in ai_data.read(layer)]# the first two reviews whose only detected name is Patricknamed = [(text, spans) for text, spans in found if [text[s.start:s.end] for s in spans] == ["Patrick"]][:2]print("reviews naming Patrick:", len(named))def replaced(operator: OperatorConfig) -> list[str]:    """The value that replaced the name in each of the two reviews."""    results = [AnonymizerEngine().anonymize(text, spans, {"PERSON": operator}) for text, spans in named]    return [result.text[item.start:item.end] for result in results for item in result.items]# Presidio's hash salts each value at random, so the same name gets a different hash in each reviewhashed = replaced(OperatorConfig("hash"))assert hashed[0] != hashed[1]print("Presidio's hash, the same name in two reviews gets one value:", hashed[0] == hashed[1])# and hashing the same review again gives it a different hash toorehashed = replaced(OperatorConfig("hash"))[0]assert rehashed != hashed[0]print("Presidio's hash, one review hashed twice gets one value:", rehashed == hashed[0])# a fixed salt must be at least 16 bytes; this one is 10, so Presidio refuses ittry:    replaced(OperatorConfig("hash", {"salt": "ten bytes!"}))except InvalidParamError as error:    print("a fixed salt of 10 bytes:", error)# the custom operator's lambda returns the keyed pseudonym as the replacementkeyed = replaced(OperatorConfig("custom", {"lambda": lambda value: ai_data.pseudonym("PERSON", value)}))print("keyed pseudonyms:", ", ".join(keyed))print("the name typed in lowercase:", ai_data.pseudonym("PERSON", "patrick"))# the first word of each instructor's full namefirst_names = Counter(name.split()[0] for name in load("crm.instructors").column("full_name").to_pylist())shared = sum(n for n in first_names.values() if n > 1)assert shared == 0print("instructors who share a first name with another:", shared)# What the enforcement layer's pseudonymize mask makes of the same name, run by the layer under its own key.mask = enforce.masked("pseudonymize", exp.Literal.string("Patrick"), "VARCHAR").sql(enforce.DIALECT)print("the enforcement layer's pseudonymize mask, on the same name:", layer.run(f"select {mask}").fetchall()[0][0])# functions whose name mentions HMAC: the prose says DuckDB has nonehmac = layer.connection.sql("select count(*) from duckdb_functions() where function_name ilike '%hmac%'").fetchall()[0][0]assert hmac == 0print("HMAC functions in DuckDB:", hmac)
Salidapython keyed-pseudonyms.py
reviews naming Patrick: 2
Presidio's hash, the same name in two reviews gets one value: False
Presidio's hash, one review hashed twice gets one value: False
a fixed salt of 10 bytes: Salt must be at least 16 bytes (128 bits). Provided salt is 10 bytes.
keyed pseudonyms: <PERSON_d14171be>, <PERSON_d14171be>
the name typed in lowercase: <PERSON_d14171be>
instructors who share a first name with another: 0
the enforcement layer's pseudonymize mask, on the same name: 23b3d8671d01840655296f752121aecc4f7991694260e5e1431d2b57c5e3d53f
HMAC functions in DuckDB: 0

El operador hash de Presidio asigna al mismo nombre un valor distinto en cada una de las dos reseñas, y asigna a una reseña un valor distinto cada vez que se calcula el hash. Presidio también rechaza una sal fija demasiado corta, aquí de 10 bytes, con Salt must be at least 16 bytes (128 bits). Provided salt is 10 bytes., como indica la documentación. El hash con clave asigna a ambas reseñas <PERSON_d14171be>, <PERSON_d14171be>, y el nombre escrito en minúsculas recibe <PERSON_d14171be> también.

La máscara pseudonymize de la capa de cumplimiento, aplicada por la capa sobre el mismo nombre, produce 23b3d8671d01840655296f752121aecc4f7991694260e5e1431d2b57c5e3d53f. Es SHA-256 sobre la clave de la capa seguida del valor, como lo escribe el capítulo 6, y no un HMAC, porque las máscaras de la capa son SQL y DuckDB 2.0.0 no tiene una función HMAC. Las dos son construcciones distintas bajo claves distintas, así que los seudónimos del corpus no pueden unirse con los que la capa muestra a los analistas.

La consistencia tiene dos costes. Quien posea la clave y una lista de nombres puede calcular todos los seudónimos, como mostró el capítulo 6 para los correos, así que la clave vive en un gestor de secretos, nunca en el corpus, el repositorio o un registro. Los seudónimos con clave también separan reseñas que los marcadores fusionarían: 96 textos distintos frente a 21, lo que mide la sección siguiente. Recomendamos seudónimos con clave cuando el significado del texto depende de distinguir a las personas, como en un ticket que nombra a un agente y a un alumno, y marcadores cuando nada posterior necesita distinguirlas.

Regla práctica: Crea seudónimos con HMAC bajo una clave que solo posea el trabajo, y da a cada corpus o audiencia cuyos seudónimos no deban unirse una clave propia. Nunca uses el operador hash de Presidio sin sal para seudónimos, pues en su versión fijada cada hash es aleatorio. Seudonimiza el ID de una persona en lugar de una palabra de su nombre cuando dos personas puedan compartirlo, y usa un marcador simple cuando nada posterior necesite distinguir personas.

Encuentra casi duplicados con MinHash

Último cambio en la edición 2026.11.31

Una vez que sus nombres están seudonimizados, el siguiente problema del corpus es la repetición: plantillas, copias, una reseña pegada dos veces, la misma frase de muchas personas. La repetición es un problema de privacidad además de un problema de calidad. Kandpal, Wallace y Raffel encontraron que "una secuencia que aparece 10 veces en los datos de entrenamiento se genera, en promedio, unas ~1000 veces más que una secuencia que aparece solo una vez" (Kandpal et al., 2022).

Las casi copias necesitan una medida de similitud. Broder definió la resemblanza de dos documentos como la similitud de Jaccard de sus conjuntos de shingles, los tramos de caracteres o palabras que se solapan en un texto. Mostró que muestrear los shingles más pequeños bajo una permutación aleatoria da una estimación insesgada de esa resemblanza (Broder, 1997). Tomar el shingle más pequeño bajo cada una de muchas permutaciones da una firma MinHash, que estima la similitud de dos textos sin comparar sus conjuntos (Mining of Massive Datasets, sección 3.3).

lib.ai_data.deduplicate elimina primero las copias exactas, mediante SHA-256 del texto con mayúsculas y minúsculas unificadas y con los tramos de espacios en blanco reducidos a uno. Compara lo que queda como conjuntos de shingles de 5 caracteres con MinHash y MinHashLSH de datasketch, que devuelve pares candidatos, y confirma cada candidato por su similitud de Jaccard exacta. Un par confirmado con 0.8 o más es un casi duplicado, salvo que difiera solo en un nombre, y de cada grupo de duplicados se conserva el registro con el ID de reseña más bajo. El paso de duplicados se ejecuta sobre las reseñas seudonimizadas, y cada etapa informa de lo que eliminó:

corpus-duplicates.py Python 3.12.15 · datasketch 2.0.0 · duckdb 2.0.0 · mlcroissant 1.1.1 · openlineage-python 1.55.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · presidio-anonymizer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · regopy 1.5.2 · sqlglot 30.33.0 · tldextract 5.4.0 Superado
"""Runs the corpus's duplicate step on the pseudonymized reviews: exact copies, then near-duplicates by MinHash LSH, each confirmed exactly, and the records kept. The prose's point rests on the "of them, differing only in a name" and "near-duplicates removed" lines."""from collections import Counterfrom lib import ai_datafrom lib.catalog import open_catalogfrom lib.enforce import Enforcer# The reviews the corpus job reads, pseudonymized, then deduplicated: exact copies, then near-duplicates.# the reviews read, each text pseudonymized; the second value counts the replacementsrows, _ = ai_data.read_pseudonymized(Enforcer(open_catalog(["crm.learners", "learning.courses", "learning.reviews"])))# groups of reviews that stand for one record, and how many each step removedgroups, removed = ai_data.duplicate_groups(rows)print("reviews read:", len(rows))# one review per distinct normalized text: the one with the lowest review IDprint("distinct texts:", len(ai_data.exact_distinct(rows)))for step, count in removed.items():    print(f"{step}:", count)print("records kept:", len(groups))print("share of the reviews read that duplicate another:", f"{1 - len(groups) / len(rows):.0%}")# identical texts only, before normalizationtext, copies = Counter(row["body"] for row in rows).most_common(1)[0]print("the most repeated text:", text)print("its copies:", copies)# A pair MinHash finds and the exact comparison confirms, and whether it differs only in a name.distinct = [row["body"] for row in ai_data.exact_distinct(rows)]# the first confirmed pair, by position among the distinct textsi, j = sorted(ai_data.near_duplicates(distinct).confirmed)[0]print("a near-duplicate pair:", distinct[i], "|", distinct[j])print("its Jaccard similarity:", f"{ai_data.jaccard(distinct[i], distinct[j]):.2f}")# equal once each pseudonym is a placeholder: the pair differs only in which names it holdsprint("it differs only in a name:", ai_data.placeholders(distinct[i]) == ai_data.placeholders(distinct[j]))# Each record kept stands for its group's reviews, under the review ID and course of the first.# a group whose reviews come from more than one courseseveral = sum(len({row["course_id"] for row in group}) > 1 for group in groups)print("records that stand for reviews of several courses:", several)
Salidapython corpus-duplicates.py
reviews read: 436
distinct texts: 96
exact duplicates removed: 340
near-duplicate pairs from LSH: 381
near-duplicate pairs confirmed: 8
of them, differing only in a name: 8
near-duplicates removed: 0
records kept: 96
share of the reviews read that duplicate another: 78%
the most repeated text: Clear explanations and good exercises.
its copies: 56
a near-duplicate pair: Some videos are out of date. <PERSON_85783bac> explains things well. Happy to talk about it, write to me at [email]. | Some videos are out of date. <PERSON_967f9ae8> explains things well. Happy to talk about it, write to me at [email].
its Jaccard similarity: 0.81
it differs only in a name: True
records that stand for reviews of several courses: 23

La mayor parte del corpus se repite. De las 436 reseñas leídas, 78% repiten otra: 340 son copias exactas, y solo 96 textos son distintos. Eso se debe sobre todo al generador, que construye las reseñas a partir de un puñado de frases fijas, así que mide la proporción en tu propio texto antes de entrenar con él.

El texto más repetido, "Clear explanations and good exercises.", aparece por sí solo 56 veces.

MinHash confirma luego 8 pares con 0.8 o más, como dos reseñas con una similitud de 0.81 que solo difieren en el seudónimo de su instructor. De esos pares, 8 difieren solo en un nombre, que la plataforma mantiene aparte, así que los casi duplicados eliminan 0.

La razón de que los pares que difieren solo en un nombre se mantengan aparte está en lo que significa un mismo umbral según la longitud del texto. Compara las reseñas del corpus con los nombres tal como aparecen, con seudónimos con clave y con marcadores de posición simples, y después separa cada par de textos distintos según si difiere solo en un nombre:

names-and-near-duplicates.py Python 3.12.15 · datasketch 2.0.0 · duckdb 2.0.0 · mlcroissant 1.1.1 · openlineage-python 1.55.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · presidio-anonymizer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · regopy 1.5.2 · sqlglot 30.33.0 · tldextract 5.4.0 Superado
"""Counts near-duplicate pairs of the corpus's reviews with names as written, with keyed pseudonyms and with placeholders, then splits the pairs that differ only in a name by length. The prose's point rests on the pair counts and the length ranges."""from itertools import combinationsfrom lib import ai_datafrom lib.catalog import open_catalogfrom lib.enforce import Enforcer# The reviews the corpus job reads, three ways: names as written, keyed pseudonyms, and plain placeholders.layer = Enforcer(open_catalog(["crm.learners", "learning.courses", "learning.reviews"]))keyed, _ = ai_data.read_pseudonymized(layer)# the same reviews with each pseudonym replaced by a plain placeholder, as the third wayways = {"names as written": ai_data.read(layer), "keyed pseudonyms": keyed,        "placeholders": [row | {"body": ai_data.placeholders(row["body"])} for row in keyed]}# the similarity at which a pair is a near-duplicatethreshold = ai_data.DUPLICATES["threshold"]for way, rows in ways.items():    texts = [row["body"] for row in ai_data.exact_distinct(rows)]    print(f"{way}, distinct texts:", len(texts))    print(f"{way}, pairs at {threshold} or more:", len(ai_data.near_duplicates(texts).confirmed))# Every pair of distinct pseudonymized texts, split by whether the pair differs only in a name.# distinct texts only, so each text appears once in the pairstexts = [row["body"] for row in ai_data.exact_distinct(keyed)]name_only, other = [], []for a, b in combinations(texts, 2):    # similarity comes first, so min and max over these tuples order the pairs by it    pair = (ai_data.jaccard(a, b), len(a), a, b)    (name_only if ai_data.placeholders(a) == ai_data.placeholders(b) else other).append(pair)print("pairs that differ only in a name:", len(name_only))# the lowest and highest similarity among the name-only pairsprint("their Jaccard similarity:", f"{min(name_only)[0]:.2f} to {max(name_only)[0]:.2f}")for label, lengths in [(f"below {threshold}", [n for s, n, _, _ in name_only if s < threshold]),                       (f"at {threshold} or more", [n for s, n, _, _ in name_only if s >= threshold])]:    print(f"their length in characters, {label}:", f"{min(lengths)} to {max(lengths)}")# the most similar pair among those that differ in more than a namesimilarity, _, a, b = max(other)print("the most similar pair that differs in more than a name:", f"{similarity:.2f}")print("that pair:", a, "|", b)
Salidapython names-and-near-duplicates.py
names as written, distinct texts: 96
names as written, pairs at 0.8 or more: 10
keyed pseudonyms, distinct texts: 96
keyed pseudonyms, pairs at 0.8 or more: 8
placeholders, distinct texts: 21
placeholders, pairs at 0.8 or more: 0
pairs that differ only in a name: 459
their Jaccard similarity: 0.68 to 0.83
their length in characters, below 0.8: 66 to 78
their length in characters, at 0.8 or more: 116 to 119
the most similar pair that differs in more than a name: 0.66
that pair: Clear explanations and good exercises. Happy to talk about it, write to me at [email]. | Clear explanations and good exercises. <PERSON_3026fb67> explains things well. Happy to talk about it, write to me at [email].

Qué pares alcanzan 0.8 depende de lo que ocupe el lugar de cada nombre. Con los nombres tal como aparecen, 10 pares alcanzan 0.8, y con seudónimos con clave 8, ya que un seudónimo es más largo que la mayoría de los nombres de pila y así ocupa una proporción mayor de una reseña corta. Con marcadores de posición simples, los 21 textos distintos contienen 0.

Entre los textos seudonimizados, 459 pares difieren solo en qué seudónimo contienen, con similitudes desde 0.68 to 0.83, y el umbral los separa solo por longitud: los que quedan por debajo de 0.8 tienen 66 to 78 caracteres de longitud, y los que llegan a 0.8 o más tienen 116 to 119 caracteres.

Así que la tarea, no el umbral, decide si tales reseñas son duplicados: para un modelo que aprende cómo describen los alumnos los cursos, lo son, y para uno que aprende qué dicen los alumnos de cada instructor, no lo son. El asistente de la plataforma responde sobre cada curso y su instructor, así que name_only_pairs_are_duplicates = false en governance/ai_data.toml, y deduplicate nunca fusiona dos textos que son iguales una vez que sus seudónimos son marcadores de posición. El umbral decide los demás pares. El más similar de ellos, con 0.66, es una reseña con y sin su frase sobre el instructor: dos reseñas distintas. La plataforma mantiene 0.8, que queda por encima de ese par con margen.

Deduplicar por texto funde reseñas de cursos distintos en un solo registro, bajo el ID de reseña y el curso de su primera reseña, así que el corpus conserva 96 registros, y 23 de ellos representan reseñas de varios cursos. Para el entrenamiento ese es el objetivo, ya que el modelo aprende del texto. Para fundamentar una respuesta sobre un curso concreto cuesta exhaustividad (recall), un asunto que trata la sección de procedencia.

Regla práctica: Deduplica el texto de entrenamiento en dos pasos, primero las copias exactas mediante un hash del texto normalizado y luego los casi duplicados mediante MinHash, cada uno confirmado por su similitud exacta, e informa de cuánto eliminó cada paso. Seudonimiza primero, de modo que ningún nombre llegue a la comparación ni a las firmas y la comparación pueda identificar qué pares difieren solo en un nombre. Mantén esos pares aparte cuando el significado del texto dependa de a quién nombra, y compara con marcadores de posición cuando no dependa. Elige el umbral leyendo los pares próximos por encima y por debajo de él en tu propio texto.

Ajusta LSH para la exhaustividad (recall) y luego confirma cada par

Último cambio en la edición 2026.11.31

Las firmas MinHash hacen que cada comparación sea barata; el hashing sensible a la localidad (LSH) evita la mayoría de las comparaciones. LSH divide cada firma en b bandas de r filas, y dos textos se convierten en un par candidato cuando todas las filas de alguna banda coinciden. Leskovec, Rajaraman y Ullman deducen la probabilidad de que un par con similitud de Jaccard s se convierta en par candidato (Mining of Massive Datasets, capítulo 3):

P(candidato) = 1 − (1 − sʳ)ᵇ

Se trata de una curva en forma de S: un par muy por debajo del umbral rara vez es candidato, uno muy por encima casi siempre lo es, y cerca del umbral es casi como lanzar una moneda al aire. El umbral aproximado de la curva es (1/b)^(1/r). La documentación de datasketch advierte de ambos tipos de error: "There will be false positives - sets that do not satisfy your threshold but returned, and false negatives - qualifying sets that are not returned" (datasketch, MinHash LSH).

Con 96 textos distintos, la plataforma puede permitirse comparar exactamente cada par, 4,560 pares, y eso da los pares exactos con los que medir LSH. LSH solo ve la similitud, así que debe devolver todos los pares a 0.8, sea cual sea la regla de nombres que decida después. Compara LSH con la comparación exacta, ajustado para 0.8 y ajustado a un valor menor, cada uno con el hashing predeterminado de datasketch y con el hashing que usaba antes de su versión 2.0.0:

lsh-misses-near-duplicates.py Python 3.12.15 · datasketch 2.0.0 · duckdb 2.0.0 · mlcroissant 1.1.1 · openlineage-python 1.55.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · presidio-anonymizer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · regopy 1.5.2 · sqlglot 30.33.0 · tldextract 5.4.0 Superado
"""Measures the pairs LSH misses against every pair compared exactly, under two tunings and two hashing schemes, and shows what datasketch does with sketches of two schemes. The prose's point rests on the "missed" lines."""from itertools import combinationsfrom datasketch import MinHashLSHfrom lib import ai_datafrom lib.catalog import open_catalogfrom lib.enforce import Enforcerrows, _ = ai_data.read_pseudonymized(Enforcer(open_catalog(["crm.learners", "learning.courses", "learning.reviews"])))texts = [row["body"] for row in ai_data.exact_distinct(rows)]# the similarity at which a pair is a near-duplicatethreshold = ai_data.DUPLICATES["threshold"]# Every pair compared exactly: possible at this size, and the truth LSH is measured against.pairs = {(i, j) for i, j in combinations(range(len(texts)), 2) if ai_data.jaccard(texts[i], texts[j]) >= threshold}print("pairs compared exactly:", f"{len(texts) * (len(texts) - 1) // 2:,}")print(f"pairs at a Jaccard similarity of {threshold} or more:", len(pairs))found = {}for scheme in ["affine32", "legacy"]:    # LSH tuned for the threshold, and for the lower candidate threshold    for tuned_for in [threshold, ai_data.DUPLICATES["candidate_threshold"]]:        # the bands and rows LSH chose, its candidates, and the candidates the exact check confirms        found[scheme, tuned_for] = result = ai_data.near_duplicates(texts, threshold, tuned_for, scheme)        setting = f"{scheme}, LSH tuned for {tuned_for}"        print(f"{setting}, bands:", result.bands)        print(f"{setting}, rows per band:", result.rows)        print(f"{setting}, candidate pairs:", len(result.candidates))        print(f"{setting}, confirmed:", len(result.confirmed))        # pairs the exact comparison found that LSH never proposed as candidates        missed = len(pairs - result.candidates)        print(f"{setting}, missed:", missed)        if tuned_for != threshold:            assert missed == 0  # tuned lower, LSH finds every pair under either scheme# The chance that a pair of similarity s becomes a candidate, with b bands of r rows: 1 - (1 - s^r)^b.# the bands and rows LSH chose for the threshold, as the formula uses themb, r = found["affine32", threshold].bands, found["affine32", threshold].rowsfor s in [0.8, 0.9]:    print(f"chance of a candidate at similarity {s}, LSH tuned for {threshold}:", f"{1 - (1 - s ** r) ** b:.2f}")# the S-curve's approximate threshold, which the prose compares with the threshold asked forprint("the approximate threshold, (1/b)^(1/r):", f"{(1 / b) ** (1 / r):.2f}")# What datasketch does with a sketch made under the other scheme.# an index takes sketches of one scheme, so the legacy sketch below is refusedindex = MinHashLSH(threshold=threshold, num_perm=ai_data.DUPLICATES["num_perm"])index.insert(0, ai_data.minhash(texts[0], "affine32"))try:    index.insert(1, ai_data.minhash(texts[1], "legacy"))except ValueError as error:    print("a legacy sketch in an index of affine32 sketches:", error)
Salidapython lsh-misses-near-duplicates.py
pairs compared exactly: 4,560
pairs at a Jaccard similarity of 0.8 or more: 8
affine32, LSH tuned for 0.8, bands: 9
affine32, LSH tuned for 0.8, rows per band: 13
affine32, LSH tuned for 0.8, candidate pairs: 36
affine32, LSH tuned for 0.8, confirmed: 1
affine32, LSH tuned for 0.8, missed: 7
affine32, LSH tuned for 0.6, bands: 18
affine32, LSH tuned for 0.6, rows per band: 7
affine32, LSH tuned for 0.6, candidate pairs: 381
affine32, LSH tuned for 0.6, confirmed: 8
affine32, LSH tuned for 0.6, missed: 0
legacy, LSH tuned for 0.8, bands: 9
legacy, LSH tuned for 0.8, rows per band: 13
legacy, LSH tuned for 0.8, candidate pairs: 52
legacy, LSH tuned for 0.8, confirmed: 6
legacy, LSH tuned for 0.8, missed: 2
legacy, LSH tuned for 0.6, bands: 18
legacy, LSH tuned for 0.6, rows per band: 7
legacy, LSH tuned for 0.6, candidate pairs: 406
legacy, LSH tuned for 0.6, confirmed: 8
legacy, LSH tuned for 0.6, missed: 0
chance of a candidate at similarity 0.8, LSH tuned for 0.8: 0.40
chance of a candidate at similarity 0.9, LSH tuned for 0.8: 0.93
the approximate threshold, (1/b)^(1/r): 0.84
a legacy sketch in an index of affine32 sketches: MinHash scheme 'legacy' does not match scheme 'affine32' of the MinHash previously given to this index

Ajustado para 0.8, el LSH predeterminado de datasketch devuelve 36 pares candidatos, no detecta 7 de los 8 pares que alcanzan 0.8, y así solo confirma 1 de ellos.

La fórmula explica por qué. Con las 9 bandas de 13 filas que eligió datasketch, un par con similitud 0.8 se convierte en candidato con una probabilidad de 0.40, uno con 0.9 con 0.93, y el umbral aproximado es 0.84, por encima del umbral solicitado.

Con el esquema predeterminado, ajustado para 0.6, LSH encuentra todos los pares y devuelve 381 candidatos. Cada candidato cuesta una comparación exacta, frente a 4,560 para comparar cada par, y la comparación exacta descarta todo par por debajo de 0.8. Por eso la plataforma ajusta LSH para 0.6 y confirma a 0.8, ambos valores en governance/ai_data.toml.

La versión 2.0.0 de datasketch convirtió affine32 en el esquema de permutación predeterminado de MinHash, y sus notas de la versión indican que los valores hash difieren de versiones anteriores, así que aconsejan reconstruir las firmas y los índices LSH persistidos, o pasar MinHash(..., scheme="legacy"). Con el esquema heredado (legacy), LSH ajustado para 0.8 devuelve 52 candidatos y confirma 6, así que un recuento registrado con un esquema no se reproduce con el otro.

Ajustados para 0.6, ambos esquemas encuentran los 8 pares. Con un recall alto y una comprobación exacta, el resultado depende de la similitud, no de las funciones hash.

datasketch se niega a mezclar esquemas en un mismo índice, con MinHash scheme 'legacy' does not match scheme 'affine32' of the MinHash previously given to this index, pero no impide comparar recuentos antiguos con nuevos. Los ejemplos del libro fijan datasketch en 2.0.0 y escriben scheme = "affine32" en la configuración, así que una actualización no puede cambiar un recuento registrado sin un cambio revisado.

Regla práctica: Ajusta LSH por debajo de tu umbral de similitud, de modo que pase por alto pocos pares, y confirma cada candidato por su similitud exacta. Mide los fallos de LSH frente a una comparación exhaustiva sobre una muestra de tu corpus siempre que cambien sus ajustes, su biblioteca o el texto. Fija la biblioteca de MinHash, escribe su esquema de hashing en tu configuración, y nunca compares recuentos ni firmas almacenadas creados con esquemas distintos.

Incluye procedencia en cada registro

Último cambio en la edición 2026.11.27

Un registro que no puede rastrearse hasta su fuente no puede verificarse, corregirse ni eliminarse. La procedencia a nivel de registro responde a tres preguntas: de qué tabla proviene, qué fila es y qué ejecución de qué trabajo lo incorporó al corpus. El capítulo 4 aporta a la plataforma la última parte: cada ejecución de un trabajo envía eventos de OpenLineage, con un ID de ejecución derivado del momento de la ejecución y del nombre del trabajo, y con el linaje de columnas analizado a partir del SQL del trabajo.

lib.ai_data.build escribe cada registro con su procedencia junto a las columnas propias de la reseña: source_table, review_id, job y run_id. Envía los eventos de ejecución del trabajo con lib.lineage.record. Hay una elección que importa: el linaje se analiza a partir de la consulta tal como la ejecutó la capa de cumplimiento, con el filtro de consentimiento y la máscara incluidos, y no a partir del SQL de pipelines/review_corpus.sql. Construye el corpus y, después, sigue un registro hasta su ejecución:

corpus-provenance.py Python 3.12.15 · datasketch 2.0.0 · duckdb 2.0.0 · mlcroissant 1.1.1 · openlineage-python 1.55.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · presidio-anonymizer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · regopy 1.5.2 · sqlglot 30.33.0 · tldextract 5.4.0 Superado
"""Builds the corpus and follows one record back to its source row, its job and the run that wrote it, then checks that run's lineage against the query as written. The prose's point rests on the "rows filtered by" and "body" lines."""from lib import ai_data, lineage, pipelinesfrom lib.catalog import open_catalogcatalog = open_catalog(["crm.learners", "learning.courses", "learning.reviews"])built = ai_data.build(catalog)# the second record, whose text holds a pseudonymrecord = built.records.to_pylist()[1]print("a record's text:", record["body"])for column in ["source_table", "review_id", "job"]:    print(f"its {column}:", record[column])# The run that wrote it, from the lineage events: the query as the enforcement layer ran it.# the job's COMPLETE event, which carries the run's lineagecomplete = [e for e in lineage.read_events(built.folder / "events.jsonl") if e["eventType"] == "COMPLETE"][0]same_run = record["run_id"] == complete["run"]["runId"]assert same_runprint("its run_id is the COMPLETE event's run:", same_run)print("the run's inputs:", ", ".join(dataset["name"] for dataset in complete["inputs"]))# column lineage: the inputs that filter the rows, and how each field is transformedfacet = complete["outputs"][0]["facets"]["columnLineage"]# a FILTER transformation marks an input whose values decide which rows the output holdsfilters = [f"{i['name']}.{i['field']}" for i in facet["dataset"] if any(t["subtype"] == "FILTER" for t in i["transformations"])]print("rows filtered by, as run:", ", ".join(filters))# the lineage of the review text, from the reviews tabletext = [i for i in facet["fields"]["body"]["inputFields"] if (i["name"], i["field"]) == ("learning.reviews", "body")]# IDENTITY means copied unchanged; TRANSFORMATION means the value was changed on its wayprint("body, as run:", text[0]["transformations"][0]["subtype"])# the same lineage parsed from the SQL as written, with no enforcement rewritefields, rows = lineage.column_lineage(pipelines.sql(ai_data.BUILD["job"]), lineage.schema(catalog))print("rows filtered by, as written:", ", ".join(i.source for i in rows if i.subtype == "FILTER") or "nothing")print("body, as written:", fields["body"][0].subtype)# Back from every record to its review's author, with the platform's own access, against today's answers.# each record's review ID, checked against the author's consent today, not at build timeids = built.records.column("review_id").to_pylist()print("records whose author consented:", f"{ai_data.consenting(catalog, ids)} of {len(ids)}")
Salidapython corpus-provenance.py
a record's text: Too fast in the second half. <PERSON_85783bac> explains things well.
its source_table: learning.reviews
its review_id: 18
its job: platform/review_corpus
its run_id is the COMPLETE event's run: True
the run's inputs: crm.learners, learning.courses, learning.reviews
rows filtered by, as run: crm.learners.ai_training_consent, learning.reviews.learner_id
body, as run: TRANSFORMATION
rows filtered by, as written: nothing
body, as written: IDENTITY
records whose author consented: 96 of 96

Seguir un registro hacia atrás muestra lo que el linaje tiene que registrar. El registro "Too fast in the second half. <PERSON_85783bac> explains things well." proviene de learning.reviews, reseña 18, escrito por el trabajo platform/review_corpus, y su run_id es la ejecución del evento COMPLETE del trabajo.

Esa ejecución leyó crm.learners, learning.courses, learning.reviews, y su linaje dice que las filas se filtraron por crm.learners.ai_training_consent, learning.reviews.learner_id, las entradas INDIRECT que deciden qué filas existen, y que body es una TRANSFORMATION del texto de la reseña.

Analizado a partir del SQL del pipeline tal como está escrito, las filas del mismo trabajo se filtran por nothing, y body es una copia IDENTITY. Eso diría que el texto personal se copió sin cambios, sin que intervenga ninguna columna de consentimiento. La consulta tal como se ejecutó es lo que ocurrió, así que es lo que registra el linaje.

La procedencia hace que el corpus sea verificable a posteriori. Al unir cada registro con su autor a través de learning.reviews se encuentran 96 of 96 registros cuyo autor dio su consentimiento, una comprobación que la plataforma puede ejecutar sobre cualquier compilación antigua con las respuestas de hoy.

La procedencia también permite que la recuperación respete los permisos de cada lector. OWASP pide que las aplicaciones construidas sobre modelos de lenguaje "implementen controles de acceso detallados y almacenes de vectores e incrustaciones que tengan en cuenta los permisos" (OWASP LLM08:2025). La plataforma responde a una persona desde un índice construido a partir de este corpus, lo que mantiene la review_id de cada registro junto con sus vectores. Antes de que un registro recuperado llegue al modelo, la capa de recuperación le pregunta a la capa de cumplimiento, como la persona a la que se responde, cuáles de esas reseñas puede leer, de la misma forma en que el capítulo 6 ejecuta las consultas de un asistente, y descarta el resto. Así, un instructor solo recibe registros de sus propios cursos. Un registro que representa reseñas de varios cursos lleva el ID de la primera reseña, de modo que la comprobación falla de forma segura: en cada uno de los 23 registros de ese tipo, puede ocultar un texto que la persona sí podría leer, pero nunca muestra uno que no pueda leer.

Regla práctica: Dale a cada registro su tabla de origen, el ID de su fila y el trabajo y la ejecución que lo escribieron, y registra el linaje del trabajo a partir de la consulta tal como se ejecutó, con sus filtros y máscaras incluidos. Verifica las compilaciones antiguas contra el consentimiento actual a través de esa procedencia. Filtra cada recuperación según la decisión propia del lector sobre la fila de origen de cada registro, antes de que un modelo lo vea.

Genera la tarjeta del conjunto de datos a partir de la ejecución

Último cambio en la edición 2026.11.27

Una tarjeta de conjunto de datos le indica a quien entrena o audita un modelo qué contienen sus datos, de dónde provienen y qué se les hizo. Croissant es el formato de metadatos de MLCommons para conjuntos de datos de aprendizaje automático (Akhtar et al., 2024). Su especificación 1.1 hace que una tarjeta sea verificable: "Croissant datasets must declare that they conform to the versioned schema, e.g. http://mlcommons.org/croissant/1.1", y cada conjunto de datos debe indicar una descripción, una licencia, un nombre, una URL, un creador y una fecha de publicación. Para la procedencia, la especificación recomienda la Ontología PROV del W3C (PROV-O) (Croissant 1.1). Su vocabulario de IA responsable añade propiedades como rai:dataCollection y rai:personalSensitiveInformation (Croissant RAI 1.0). Una tarjeta escrita a mano describe los datos que alguien quiso construir; una tarjeta generada por la ejecución describe los datos que realmente se construyeron.

lib.ai_data.card genera la tarjeta de la plataforma con mlcroissant 1.1.1, la biblioteca de Python de MLCommons para Croissant. La ejecución aporta los recuentos, el SHA-256 del archivo del corpus, un campo por cada columna y tres propiedades de PROV-O: las tablas que lee el SQL propio de la canalización, de las que proceden los valores, como prov:wasDerivedFrom; la tabla que añade la reescritura de la capa de cumplimiento, que solo decide qué filas existen, como prov:wasInfluencedBy; y la ejecución, como prov:wasGeneratedBy. mlcroissant las escribe mediante su argumento extra_properties, pero no añade el prefijo prov al contexto de la tarjeta, así que el módulo lo añade. El creador es el propietario de ai.review_corpus en governance/metadata.toml. La licencia, el nombre, la URL, la descripción y los casos de uso proceden de governance/ai_data.toml, y lib.ai_data.card_problems es la comprobación propia de la plataforma sobre el resultado. Genera la tarjeta, primero con el conformsTo predeterminado de mlcroissant:

corpus-dataset-card.py Python 3.12.15 · datasketch 2.0.0 · duckdb 2.0.0 · mlcroissant 1.1.1 · openlineage-python 1.55.0 · phonenumbers 9.0.43 · presidio-analyzer 2.2.366 · presidio-anonymizer 2.2.366 · pyarrow 26.0.1 · pyiceberg 0.12.0 · pyyaml 6.0.3 · regopy 1.5.2 · sqlglot 30.33.0 · tldextract 5.4.0 Superado
"""Generates the corpus's Croissant card twice, first with mlcroissant's default conformsTo and then as the platform writes it, and runs the platform's own check on it. The prose's point rests on the "conformsTo" lines and the "problems" line."""from lib import ai_datafrom lib.catalog import open_catalogbuilt = ai_data.build(open_catalog(["crm.learners", "learning.courses", "learning.reviews"]))# mlcroissant's default, then the card the pipeline writes, with Croissant 1.1 written out.# an empty list leaves conformsTo to mlcroissant, which writes its own defaultdefault, _ = ai_data.card(built, conforms_to=[])print("conformsTo, mlcroissant's default:", default["conformsTo"])# the card as the platform writes it: Croissant 1.1 and the RAI vocabulary, written outcard, warnings = ai_data.card(built)ai_data.write_card(card, built.folder)print("conformsTo, written out:", ", ".join(card["conformsTo"]))print("datePublished, the run's:", card["datePublished"])# the build's date as the major number: a nightly build may remove recordsprint("version, the run's:", card["version"])print("the sources the card names:", ", ".join(source["@id"] for source in card["prov:wasDerivedFrom"]))print("the tables that decided which rows, as the card names them:",      ", ".join(table["@id"] for table in card["prov:wasInfluencedBy"]))print("the activity the card names:", card["prov:wasGeneratedBy"]["prov:label"])# the card names every column of the corpus as a fieldprint("fields in the record set:", ", ".join(f["name"] for f in card["recordSet"][0]["field"]))for line in card["rai:dataPreprocessingProtocol"] + card["rai:personalSensitiveInformation"]:    print("-", line)# What mlcroissant reports, and what the platform's own check of the card reports.# the message after mlcroissant's severity tagprint("mlcroissant's warnings:", len(warnings))for warning in warnings:    print("- mlcroissant:", warning.split("] ", 1)[1])# the platform's own check: the library's validator doesn't report every requirementproblems = ai_data.card_problems(card, built.folder)print("problems the book's check finds:", len(problems))for problem in problems:    print("-", problem)
Salidapython corpus-dataset-card.py
conformsTo, mlcroissant's default: http://mlcommons.org/croissant/1.0
conformsTo, written out: http://mlcommons.org/croissant/1.1, http://mlcommons.org/croissant/RAI/1.0
datePublished, the run's: 2026-10-01T02:00:00Z
version, the run's: 20261001.0.0
the sources the card names: iceberg://platform/learning.courses, iceberg://platform/learning.reviews
the tables that decided which rows, as the card names them: iceberg://platform/crm.learners
the activity the card names: platform/review_corpus
fields in the record set: review_id, course_id, course_title, rating, body, source_table, job, run_id
- Read 436 of 3,000 reviews, filtered on crm.learners.ai_training_consent, learning.reviews.learner_id.
- Replaced personal data with keyed pseudonyms (PERSON 120).
- Removed 340 exact duplicates and 0 near-duplicates (MinHash LSH, Jaccard similarity of 0.8 or more, confirmed exactly; 8 pairs that differ only in a name kept apart).
- Kept 96 records, each with its source table, review ID, job and run.
- Values replaced by keyed pseudonyms: PERSON 120.
- Emails and phone numbers replaced by [email] and [phone] by the enforcement layer's redact_contacts mask.
- Names found with a list of 106 words from crm.instructors, built by the governance team's job governance/instructor_names; the list isn't part of the corpus.
- Measured against labelled spans: 0 of 139 labelled values left in the text.
mlcroissant's warnings: 1
- mlcroissant: Property "http://mlcommons.org/croissant/citeAs" is recommended, but does not exist.
problems the book's check finds: 1
- creator: missing

Con su valor predeterminado, mlcroissant escribe http://mlcommons.org/croissant/1.0, aunque su propio LATEST_VERSION es 1.1 (código fuente de mlcroissant), de modo que una tarjeta declararía una versión para la que no fue escrita. La plataforma escribe http://mlcommons.org/croissant/1.1, http://mlcommons.org/croissant/RAI/1.0.

El datePublished de la tarjeta, 2026-10-01T02:00:00Z, es la hora de la compilación, porque la plataforma solo publica una tarjeta con la compilación que describe. Su version, 20261001.0.0, toma la fecha de la compilación como su número de versión mayor. Croissant recomienda MAJOR.MINOR.PATCH, donde una nueva versión mayor significa "the existing data has been changed (edited, removed or shuffled records across splits)", y cualquier compilación nocturna puede eliminar registros.

La tarjeta nombra las fuentes iceberg://platform/learning.courses, iceberg://platform/learning.reviews, la influencia iceberg://platform/crm.learners y la actividad platform/review_corpus, y enumera los pasos de preprocesamiento con los recuentos de la ejecución.

Las advertencias que informa mlcroissant, 1 en total, se refieren a propiedades recomendadas, aquí citeAs, y no al problema que encuentra la comprobación de la plataforma: falta creator. ai.review_corpus no tiene propietario en el archivo de metadatos, la brecha que encontró el capítulo 2, así que la tarjeta permanece sin publicar hasta que la tabla tenga propietario. El capítulo 10 informa de la misma laguna en cada ejecución, como un hallazgo ya presente en main.

mlcroissant también puede leer una tarjeta con mlc.Dataset, pero en 1.1.1, con rdflib 7.6.0 y pandas 3.1.1, la lectura emite un DeprecationWarning de rdflib y un Pandas4Warning, y devuelve los campos de texto como bytes. Por eso, los ejemplos del libro solo escriben tarjetas y las comprueban con el código propio de la plataforma.

Regla práctica: Genera la tarjeta en la ejecución que construye los datos, con cada recuento, hash, fuente y versión tomados de esa ejecución, y escribe la versión del formato de forma explícita. Comprueba la tarjeta con tu propio código para cada propiedad que exige la especificación, ya que el validador de la biblioteca no las informa todas, y no publiques ni entrenes con un corpus cuya tarjeta falle.

Citar lo que dice la Ley de IA de la UE sobre los datos de entrenamiento

Último cambio en la edición 2026.11.27

La Ley de Inteligencia Artificial de la UE, Reglamento (UE) 2024/1689, aborda los datos de entrenamiento en varios lugares. Esta sección cita dos de ellos, el artículo 10 y el artículo 53, apartado 1, letra d), y no interpretamos ninguno de los dos.

Para los sistemas de IA de alto riesgo, el artículo 10, apartado 2, establece que los conjuntos de datos de entrenamiento, validación y prueba "estarán sujetos a prácticas de gobernanza y gestión de datos", y enumera a qué se refieren esas prácticas. Incluyen los procesos de recogida de datos y el origen de los datos, con la finalidad original de la recogida de datos personales, y la preparación de los datos, como la anotación, el etiquetado, la limpieza, la actualización, el enriquecimiento y la agregación (Ley de IA).

El artículo 10, apartado 3, exige conjuntos de datos "pertinentes, suficientemente representativos y, en la mayor medida posible, exentos de errores y completos con respecto a la finalidad prevista" (Ley de IA).

El Reglamento (UE) 2026/1744, el Ómnibus Digital sobre IA, publicado el 24 de julio de 2026, deja estos pasajes tal como se citan. Sustituye los apartados 1 y 6 del artículo 10, suprime el apartado 5 e inserta un artículo 4 bis, "Tratamiento de categorías especiales de datos personales para la detección y corrección de sesgos". También establece cuándo se aplican el capítulo III, secciones 1 a 3, que incluyen el artículo 10: desde el 2 de diciembre de 2027 para los sistemas de IA de alto riesgo clasificados con arreglo al artículo 6, apartado 2, y al anexo III, y desde el 2 de agosto de 2028 para los clasificados con arreglo al artículo 6, apartado 1, y al anexo I (Reglamento (UE) 2026/1744).

Para los proveedores de modelos de IA de uso general, el artículo 53, apartado 1, letra d), les exige "elaborar y poner a disposición del público un resumen suficientemente detallado sobre el contenido utilizado para el entrenamiento del modelo de IA de uso general, siguiendo un modelo facilitado por la Oficina de IA". La Comisión Europea publicó ese modelo como C(2025) 8311 (modelo de la Comisión, PDF).

Su nota explicativa indica que una entidad posterior que modifique un modelo ya introducido en el mercado de la Unión puede convertirse en proveedor del modelo resultante, conforme a las directrices de la Comisión sobre modelos de IA de uso general que la nota menciona. En ese caso, la entidad que realiza la modificación solo informa sobre el contenido de entrenamiento utilizado para la modificación.

El anexo III de la Ley se titula "Sistemas de IA de alto riesgo a que se refiere el artículo 6, apartado 2", y su punto 3, "Educación y formación profesional", incluye "b) los sistemas de IA destinados a utilizarse para evaluar los resultados del aprendizaje, incluso cuando dichos resultados se utilicen para orientar el proceso de aprendizaje de personas físicas en instituciones de educación y formación profesional de todos los niveles" (Ley de IA). Lo citamos porque la plataforma es una plataforma educativa, y nos detenemos ahí. Si algún sistema de la plataforma es de alto riesgo con arreglo al artículo 6 es otra cuestión, y ningún código de este capítulo depende de la respuesta.

Regla práctica: cita la Ley tal como fue modificada, a partir del Diario Oficial, con un enlace y la fecha en que la consultaste, porque el Ómnibus cambió tanto el texto como las fechas. Mantén la ley fuera de la lógica de tu pipeline: genera los datos de la ficha a partir de la ejecución y deja que quienes responden las consultas jurídicas decidan qué pasajes se aplican.

Qué sale mal en producción

Último cambio en la edición 2026.11.27

Un corpus no avisa. El modelo se entrena, la ficha se publica y los problemas aparecen después, en lo que el modelo dice o en una petición que nadie sabe responder.

Un estudiante retira su consentimiento después de la compilación

Último cambio en la edición 2026.11.27

Al igual que la lista de marketing del capítulo 7, un corpus registra quién había dado su consentimiento el día en que se compiló. Toma el corpus que lib.ai_data.build escribe en la ejecución nocturna del 1 de octubre, la compilación del 1 de octubre, y retira el consentimiento del autor de uno de sus registros. Después, recompila el corpus en la misma carpeta la noche siguiente, sin generar de nuevo su tarjeta, y comprueba cada compilación contra el consentimiento de hoy, como lo hace una ejecución de entrenamiento antes de empezar:

La compilación del 1 de octubre contiene 1 registros de ese estudiante, y la del 2 de octubre contiene 0, así que el corpus siguiente deja fuera al estudiante. Las dos compilaciones son ejecuciones distintas, con sus propios identificadores de ejecución. La siguiente ejecución de entrenamiento también debe dejar fuera al estudiante, y lo mismo el siguiente índice.

Comprobada mediante la procedencia contra las respuestas de hoy, la compilación del 1 de octubre tiene 95 of 96 registros cuyo autor da su consentimiento, así que una ejecución de entrenamiento que haga la comprobación la rechaza. La compilación del 2 de octubre pasa con 95 of 95.

Lo que se creó a partir de la compilación del 1 de octubre antes de la retirada conserva la revisión: una copia de su archivo, un índice construido a partir de ella, un modelo ajustado con ella. La Junta Europea de Protección de Datos considera que «los modelos de IA entrenados con datos personales no pueden, en todos los casos, considerarse anónimos» (Dictamen 28/2024 del EDPB).

El artículo 7, apartado 3, del RGPD reconoce el derecho a retirar el consentimiento en cualquier momento. Establece que retirarlo no afecta a la licitud del tratamiento basado en el consentimiento antes de la retirada, que la persona debe ser informada de este derecho antes de dar su consentimiento, y que retirarlo debe ser tan fácil como darlo (RGPD). El capítulo 7 cita las primeras frases del mismo artículo y explica qué cambia una retirada en el código de la plataforma.

La parte del código consiste en encontrar, mediante la procedencia, cada compilación que contiene el registro y, por identificador de ejecución, cada modelo e índice creado a partir de esas compilaciones. Después lee qué ocurre con ellos a partir de [legal.withdrawal] en governance/ai_data.toml. La respuesta del equipo jurídico para un modelo creado a partir de la compilación del 1 de octubre es undecided, un marcador de posición según el cual el trabajo enumera esos modelos para el equipo jurídico y no cambia nada. Si la respuesta es que un modelo no debe conservar la revisión, la única forma de eliminarla que podemos garantizar es volver a entrenar el modelo con una compilación que no la incluya.

La tarjeta también falló, sin que se notara. Su último paso de preprocesamiento todavía dice «Kept 96 records, each with its source table, review ID, job and run.» El archivo contiene 95 registros, y la comprobación de la plataforma encuentra 2 problemas: el creador que falta y un archivo cuyo SHA-256 no es el que indica la tarjeta. Una tarjeta que no se vuelve a generar junto con sus datos describe otro conjunto de datos.

Regla práctica: Registra con qué compilación, por identificador de ejecución, se creó cada modelo e índice. Antes de cada ejecución de entrenamiento, comprueba los registros de la compilación contra el consentimiento de hoy y el hash del archivo contra su tarjeta, y rechaza toda compilación que falle en cualquiera de las dos comprobaciones. Cuando un estudiante retire su consentimiento, localiza las compilaciones que contienen sus registros y los modelos creados a partir de ellas, y deja que la respuesta de su equipo jurídico en la configuración decida qué ocurre con ellos.

Otros fallos

Último cambio en la edición 2026.11.27
  • Un filtro de negativas que conserva los desconocidos. Construido con él, el corpus contenía 2,045 reseñas en lugar de 436, sobre todo de estudiantes a quienes nunca se les preguntó. Detéctalo contando los registros del corpus por respuesta de consentimiento, a través de su procedencia: cualquier respuesta distinta de sí es un defecto.
  • Datos personales que un modelo memoriza de su texto. Carlini y sus colegas extrajeron texto de entrenamiento de un modelo de lenguaje, incluida información personal pública como nombres, números de teléfono y direcciones de correo electrónico, aunque cada una de esas secuencias aparecía en un solo documento (Carlini et al., 2021). El corpus del pipeline básico contiene 120 correos electrónicos etiquetados, 113 de ellos distintos y 106 escritos una sola vez, y los duplicados repiten en cada copia lo que un detector pasa por alto. Mide lo que queda frente a muestras etiquetadas de tu propio texto, y elimina los duplicados antes de entrenar.
  • Una clave de seudonimización que se filtra. Con la clave del corpus y una lista de los nombres de los profesores, cualquiera puede calcular todos los seudónimos del corpus. Cuando la clave pueda haberse filtrado, rótala, reconstruye todos los corpus creados con ella y localiza, por identificador de ejecución, las copias y los modelos creados a partir de construcciones con la clave anterior, como en una retirada.

Lo que decidió este capítulo

Último cambio en la edición 2026.11.27
  • El corpus se construye a través de la capa de cumplimiento, como analyst-1 para ai-training: solo entran las reseñas cuyo ai_training_consent del autor es verdadero, con los contactos enmascarados, y un consentimiento desconocido se cuenta como no.
  • Toda respuesta legal que necesita el código es un marcador de posición para el equipo jurídico en [legal] en governance/ai_data.toml: el consentimiento que admite un registro, la licencia de la ficha y lo que ocurre con los modelos creados antes de una retirada.
  • Los datos personales se detectan después de las máscaras de la capa de cumplimiento, con los reconocedores de patrones y la lista de nombres de instructores que mantiene el equipo de plataforma, y se reemplazan por seudónimos con clave. Privacy Filter se mide, no se añade. El corpus está seudonimizado, nunca anonimizado.
  • Los seudónimos son HMAC-SHA256 bajo la propia clave del trabajo del corpus, no el SHA-256 sobre clave y valor de la capa de cumplimiento, y nunca el hash con sal aleatoria de Presidio.
  • Los duplicados se eliminan en dos pasos, primero las copias exactas por SHA-256 y luego los casi duplicados de MinHash LSH ajustado para 0.6 y confirmado con una similitud de Jaccard de 0.8, sin fusionar nunca textos que solo difieren en un nombre. datasketch y su esquema, affine32, están fijados.
  • Cada registro conserva su procedencia, source_table, review_id, job y run_id, y una ejecución de entrenamiento comprueba primero su construcción frente al consentimiento vigente hoy.
  • La ficha del conjunto de datos es Croissant 1.1 con RAI 1.0, generada por la ejecución, verificada por el propio código de la plataforma y sin publicar hasta que ai.review_corpus tenga un responsable.
  • Las respuestas sobre una persona concreta provienen de un índice del corpus, filtrado según la decisión de esa persona sobre la reseña de origen de cada registro.
  • La Ley de IA de la UE se cita tal como está modificada y se enlaza, nunca se interpreta. Un corpus solo es tan limpio como lo que se admitió en él. Cada registro se decide cuando se construye el corpus, cada registro conserva su origen, de modo que una decisión puede rastrearse hasta la reseña de la que procede, y la ficha indica qué se hizo con el resto.

Este capítulo, en esta edición

Edición 2026.11.31Ejemplos verificados el 19 de nov de 2026Superan la prueba 10 de 10 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 9 de 10: Gobernar los datos para IA

  1. Admite solo reseñas cuyos autores dieron su consentimiento
  2. Reemplaza los datos personales del texto y mide lo que queda
  3. Mantén los seudónimos consistentes con un hash con clave
  4. Encuentra casi duplicados con MinHash
  5. Ajusta LSH para la exhaustividad (recall) y luego confirma cada par
  6. Incluye procedencia en cada registro
  7. Genera la tarjeta del conjunto de datos a partir de la ejecución
  8. Citar lo que dice la Ley de IA de la UE sobre los datos de entrenamiento
  9. Qué sale mal en producción
  10. Un estudiante retira su consentimiento después de la compilación
  11. Otros fallos
  12. Lo que decidió este capítulo

Volver arribaTodos los capítulos