Governança de dados para IA

Cerca de 46 minutos min de leitura, com 10 exemplos em 12 seções.

Edição 2026.11.31 Exemplos aprovados em 19 de nov de 2026 108 de 108 exemplos passam O que mudou

Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros

Traduzido do livro em inglês, edição 2026.11.31. Leia o original

Ao final deste capítulo, você será capaz de construir os dados com que um assistente de IA aprende sob as mesmas regras de qualquer outra leitura da sua plataforma. Você admitirá apenas registros cujos autores tenham concordado com esse uso, substituirá os dados pessoais deles por pseudônimos e medirá o que o detector deixou passar, removerá duplicatas encontradas com MinHash, manterá a origem de cada registro junto com ele e fará o pipeline gerar e verificar um cartão de dataset a cada execução. Você também saberá citar o que o EU AI Act diz sobre dados de treinamento.

A plataforma, a plataforma de aprendizado online que este livro acompanha, quer um assistente de curso que responda com base no que os alunos escrevem em suas avaliações. Ela planeja fundamentar o assistente nesse texto primeiro e, depois, fazer fine-tuning dele com o mesmo texto. review_corpus, um dos quatro pipelines SQL dos quais o capítulo 4 captura a linhagem, copia cada linha de learning.reviews para ai.review_corpus, com o curso e a nota de cada avaliação. O capítulo 2 constatou que ai.review_corpus não tem dono nem classificação, e a cópia tem quatro outros problemas. Ela guarda todas as avaliações, esteja ou não o autor de acordo com que o texto seja usado para treinar uma IA. Seu texto contém nomes e e-mails, que o capítulo 3 encontrou nas avaliações. A maioria das avaliações repete as outras. E nada nela indica de onde veio um registro, de modo que ninguém consegue demonstrar que uma avaliação foi admitida nem localizá-la quando o autor muda de ideia.

Este capítulo refaz o trabalho com o módulo compartilhado do livro para dados de IA, lib.ai_data, e o assistente aprende somente com essa construção governada: pipelines/review_corpus.sql permanece como a cópia não governada do capítulo 4, para que o CI continue verificando sua linhagem. O módulo executa o SQL próprio do pipeline pela camada de imposição que o capítulo 6 construiu, substitui os dados pessoais que restaram no texto, remove duplicatas e grava o corpus, sua linhagem e seu cartão de dataset. Suas configurações estão em governance/ai_data.toml, revisadas como uma política, e o mesmo vale para as respostas que o código precisa dar a questões jurídicas, cada uma um placeholder que a equipe jurídica da plataforma substitui pela sua resposta e pelo seu motivo.

Admita apenas avaliações cujos autores consentiram

Última alteração na edição 2026.11.27

Na plataforma, o consentimento para um uso não cobre outro, porque a pergunta que o estudante responde nomeia o uso. O Artigo 5(1)(b) do Regulamento Geral de Proteção de Dados (RGPD) da União Europeia diz que os dados pessoais devem ser "coletados para fins determinados, explícitos e legítimos e não tratados posteriormente de forma incompatível com esses fins" (GDPR). O código lê a resposta registrada sobre a possibilidade de treinar uma IA a partir de [legal.consent] em governance/ai_data.toml, e decide o consentimento registro a registro quando o corpus é construído, e não a partir do cadastro da conta nem uma única vez para a tabela inteira.

crm.learners.ai_training_consent registra se um estudante concordou que o seu texto treine a IA da plataforma. O Capítulo 5 transformou isso em um atributo que a política de acesso lê, de modo que uma leitura de learning.reviews para a finalidade ai-training mantém apenas as avaliações cuja resposta do autor é verdadeira, com os dados de contato removidos. lib.ai_data.read executa o SELECT de pipelines/review_corpus.sql por meio de a camada de aplicação de políticas como analyst-1, o principal de ciência de dados, declarando a finalidade. lib.ai_data.build se recusa a executar a menos que a camada filtre pela coluna que a resposta de consentimento nomeia. Compare três construções: o pipeline simples, pipelines/review_corpus.sql executado como está; a leitura governada; e um filtro de consentimento escrito à mão.

Copiado como está, o pipeline simples colocaria 120 e-mails identificados e 798 nomes identificados no corpus, a partir de 3,000 avaliações.

A leitura governada mantém 436 avaliações, aquelas cujos autores disseram sim. Sem uma finalidade, o mesmo principal obtém 3,000 avaliações, 0 delas com o seu texto; assim, uma tarefa que esquece de declarar a sua finalidade não recebe nada que possa usar para treinamento.

Observe que o filtro escrito à mão parece respeito ao consentimento, e é por isso que ele precisa ser reconhecido: ele deixa de fora os estudantes que disseram não. Ele mantém 2,045 avaliações, e 1,609 delas, 79%, são de estudantes que nunca foram perguntados. O README dos dados gerados pela plataforma diz que o consentimento é desconhecido para cadastros anteriores a 1º de junho de 2025, e todo estudante sem resposta se cadastrou a partir de Jan 1, 2024 to May 31, 2025. Uma resposta desconhecida não é um sim. Um corpus construído com esse filtro seria em sua maioria texto que nenhum consentimento cobre, e nada nele pareceria errado: nenhum erro, uma contagem de linhas plausível e uma condição sobre a coluna de consentimento que um revisor leria como correta. O filtro da camada de aplicação de políticas testa IS TRUE, de modo que uma resposta desconhecida conta como não; é exatamente esse caso que o Capítulo 6 tratou.

Na plataforma, todas as avaliações foram escritas sob um mesmo conjunto de termos, então o cartão declara uma licença, lida de [legal.licence]. Um corpus que mistura fontes, como avaliações e postagens de fóruns, precisa de uma licença por registro também, e essa é uma das razões pelas quais todo registro mantém a sua tabela de origem.

Regra prática: Decida o consentimento registro a registro, quando o corpus for construído, a partir da resposta que a sua equipe jurídica indica como cobrindo o uso, e admita apenas os registros cuja resposta seja sim: nunca filtre as recusas e mantenha o restante. Construa o corpus por meio da camada de aplicação de políticas com a finalidade declarada, e faça a construção verificar que a camada filtra por essa resposta. Mantenha as respostas da equipe jurídica, com as suas razões, em um arquivo revisado que o código lê, e registre as licenças por registro quando uma fonte misturar licenças.

Substitua os dados pessoais no texto, depois meça o que sobrou

Última alteração na edição 2026.11.27

O consentimento decide de quem é o texto que pode entrar no corpus. Isso não o torna livre de dados pessoais: uma avaliação nomeia seu instrutor, ou traz o e-mail de seu autor para perguntas. Antes que tal texto treine ou embase um modelo, a tarefa do corpus detecta os dados pessoais nele, substitui cada valor e mede o que sobrou, porque a saída de um detector lista o que ele encontrou e nunca o que deixou passar. A verdade, os trechos rotulados do capítulo 3, marca cada dado pessoal que o gerador colocou nas avaliações. lib.ai_data.left conta quantos valores rotulados ainda estão no texto após uma etapa, comparando por valor, já que cada substituição desloca as posições que vêm depois dela.

As avaliações chegam da camada de imposição com a máscara redact_contacts aplicada, que substitui e-mails e números de telefone por [email] e [phone] (capítulo 6). O detector do capítulo 3, lib.pii.platform_detector, executa os reconhecedores de padrões do Presidio sem modelo de linguagem, e nenhum padrão encontra um nome. Por isso, lib.ai_data.detector acrescenta uma lista de bloqueio do Presidio com os nomes que a plataforma conhece: cada palavra do nome de cada instrutor, que o Presidio escapa e compara como palavra inteira, ignorando maiúsculas e minúsculas, salvo indicação em contrário (reconhecedor de padrões do Presidio). A lista vem de crm.instructors, que analyst-1 não pode ler. Por isso, o trabalho da equipe da plataforma, nomeado em [names] em governance/ai_data.toml, a constrói com o acesso próprio da plataforma, da mesma forma que a camada de imposição lê crm.learners para verificar o consentimento, e entrega à tarefa do corpus somente a lista, nunca a tabela. O cartão registra qual tarefa a construiu e quantas palavras ela contém. lib.ai_data.known_names representa essa tarefa. Cada valor encontrado se torna um pseudônimo com chave, que a próxima seção constrói. Meça cada etapa nas avaliações que o corpus lê e, em seguida, experimente uma lista mais longa, com o nome de todos os alunos também:

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 Aprovado
"""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]}")
Saídapython 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

A máscara da camada de imposição deixa 0 of 19 e-mails e 120 of 120 nomes, e os reconhecedores de padrões deixam 120 of 120 nomes, já que nenhum padrão encontra um nome.

Somente a lista dos instrutores remove nomes. Com os nomes deles acrescentados, o detector deixa 0 of 120 nomes e não gera falsos positivos, embora sua lista contenha palavras curtas que um texto comum poderia conter: Ray, Roy, Ulf, Uss, de, la.

A lista mais longa, com o nome de todos os alunos também, gera 147 falsos positivos. Os mais comuns, best (80), date (67), são sobrenomes que também são palavras do inglês, e a lista transforma Some videos are out of date. em Some videos are out of <PERSON_8e2b63a6>. no corpus.

Comparar respeitando maiúsculas e minúsculas evita os dois problemas. Comparada somente da forma como está escrita, a lista mais longa não gera falsos positivos e não deixa nomes, porque cada nome nessas avaliações começa com letra maiúscula. Em texto real, ela deixaria passar os nomes digitados em minúsculas que o capítulo 3 encontrou em chamados. A plataforma mantém a lista de instrutores, comparada em qualquer caixa: instrutores são as pessoas de quem as avaliações falam, e a tarefa do corpus então guarda os nomes deles em vez do nome de todos os alunos.

O resultado da lista vale somente para estes dados. Os trechos rotulados são gerados, e as avaliações geradas nomeiam apenas instrutores, por isso não podem conter o caso que uma lista de instrutores deixa passar, como o nome de um colega de turma. Para nomes que ninguém listou, o detector a experimentar é um modelo de entidades nomeadas. O capítulo 3 comparou um, o Privacy Filter da OpenAI, a partir de um registro de suas detecções, pontuado contra os trechos rotulados com lib.pii.score. Pontue-o da mesma forma, nas avaliações que o corpus lê:

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 Aprovado
"""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)
Saídapython 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

Nessas avaliações, o modelo não pode substituir a lista, e estes dados não podem mostrar o que ele acrescenta, já que cada nome neles está na lista. Ele encontra 83 dos 120 nomes rotulados com exatidão e deixa passar 37, sobretudo Marie (4), Liwia (4), Luigi (4), onde a lista não deixa passar nenhum.

Das suas 102 detecções, 0 não se sobrepõem a nenhum trecho rotulado do mesmo tipo. Onde o texto menciona pessoas que nenhuma lista contém, execute ambos, medidos dessa forma primeiro.

O texto que sai ainda pode identificar pessoas. Um detector deixa passar trechos, o texto pode identificar alguém sem nome, e cada registro guarda um ID de avaliação que leva ao seu autor por meio de learning.reviews. O Considerando 26 do GDPR diz: "Os dados pessoais que tenham sido submetidos a pseudonimização, que possam ser atribuídos a uma pessoa singular mediante a utilização de informações adicionais, deverão ser considerados informações sobre uma pessoa singular identificável" (GDPR, Considerando 26). Por isso, chamamos o corpus de pseudonimizado, nunca de anonimizado.

Regra prática: Detecte dados pessoais no texto do corpus após as máscaras da camada de imposição, acrescente os identificadores que sua plataforma mantém sobre as pessoas de quem o texto trata, e meça o que sobrou contra dados rotulados, por valor, após cada mudança no detector. Prefira uma lista curta com os nomes de que seu texto trata a todos os nomes que você tem, já que uma lista longa casa com palavras comuns. Faça com que uma tarefa autorizada a ler os nomes construa a lista, e registre qual lista foi usada em cada corpus. Meça um modelo de entidades nomeadas da mesma forma antes de confiar nele para nomes que nenhuma lista contém. Mantenha a lista fora do corpus, e chame o resultado de pseudonimizado.

Mantenha os pseudônimos consistentes com um hash com chave

Última alteração na edição 2026.11.27

Um nome detectado pode ser substituído por um marcador, <PERSON>, ou por um pseudônimo: um token para cada nome, o mesmo onde quer que esse nome apareça. As avaliações da plataforma citam um instrutor apenas pelo primeiro nome, e não há dois instrutores com o mesmo primeiro nome, então aqui um token representa uma pessoa. Um pseudônimo preserva quem é quem, de modo que duas avaliações que elogiam o mesmo instrutor continuem dizendo isso.

O anonimizador do Presidio tem um operador hash e, desde a versão 2.2.361, ele aplica um sal aleatório a cada hash por padrão, por segurança (anonimizador do Presidio). Um sal aleatório torna cada hash não relacionável ao seguinte e, portanto, inútil como pseudônimo. Para obter o mesmo hash para o mesmo valor, a documentação diz que você "deve fornecer explicitamente um parâmetro salt", com pelo menos 128 bits (16 bytes) de comprimento.

A tarefa do corpus usa, em vez disso, seu próprio hash com chave, por meio do operador custom do Presidio, que recebe uma lambda que deve retornar uma string. lib.ai_data.pseudonym calcula um HMAC com SHA-256 do tipo de entidade e do valor com caixa dobrada, sob uma chave que apenas a tarefa do corpus possui, e mantém oito dígitos hexadecimais. HMAC é a construção que a RFC 2104 descreve para atribuir uma chave a um hash, e um de seus objetivos declarados é "Ter uma análise criptográfica bem compreendida da força do mecanismo de autenticação com base em suposições razoáveis sobre a função de hash subjacente" (RFC 2104). A biblioteca padrão do Python o oferece, como hmac, então a tarefa não tem motivo para aplicar uma chave a um hash de nenhuma outra forma.

Duas das avaliações do corpus citam o mesmo instrutor, e substituir esse nome das duas formas mostra qual delas mantém as duas ligadas:

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 Aprovado
"""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)
Saídapython 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

O hash do Presidio atribui ao mesmo nome um valor diferente em cada uma das duas avaliações, e atribui a uma avaliação um valor diferente cada vez que ela é submetida a hash. O Presidio também recusa um sal fixo curto demais, aqui de 10 bytes, com Salt must be at least 16 bytes (128 bits). Provided salt is 10 bytes., como diz a documentação. O hash com chave atribui às duas avaliações <PERSON_d14171be>, <PERSON_d14171be>, e o nome digitado em minúsculas recebe <PERSON_d14171be> também.

A máscara pseudonymize da camada de imposição, executada pela camada sobre o mesmo nome, produz 23b3d8671d01840655296f752121aecc4f7991694260e5e1431d2b57c5e3d53f. Ela é um SHA-256 sobre a chave da camada seguida do valor, como o capítulo 6 descreve, e não um HMAC, porque as máscaras da camada são SQL e o DuckDB 2.0.0 não tem função HMAC. As duas são construções diferentes sob chaves diferentes, então os pseudônimos do corpus não podem ser unidos aos que a camada mostra aos analistas.

A consistência tem dois custos. Quem detém a chave e uma lista de nomes pode calcular todo pseudônimo, como o capítulo 6 mostrou para e-mails, então a chave fica em um gerenciador de segredos, nunca no corpus, no repositório ou em um log. Pseudônimos com chave também mantêm separadas avaliações que marcadores fundiriam: 96 textos distintos contra 21, o que a próxima seção mede. Recomendamos pseudônimos com chave onde o significado do texto depende de distinguir pessoas, como em um chamado que cita um agente e um aluno, e marcadores onde nada a jusante precisa disso.

Regra prática: crie pseudônimos com HMAC sob uma chave que apenas a tarefa possui, e dê a cada corpus ou público cujos pseudônimos não devem se unir uma chave própria. Nunca use o operador hash do Presidio sem sal para pseudônimos, pois, na versão fixada, cada hash é aleatório. Pseudonimize o ID de uma pessoa, e não uma palavra do nome dela, quando duas pessoas podem compartilhar o mesmo nome, e use um marcador simples quando nada a jusante precisa distinguir pessoas.

Encontre quase-duplicatas com MinHash

Última alteração na edição 2026.11.31

Depois que os nomes dele forem pseudonimizados, o próximo problema do corpus é a repetição: modelos, cópias, uma avaliação colada duas vezes, a mesma frase de muitas pessoas. A repetição é um problema de privacidade além de um problema de qualidade. Kandpal, Wallace e Raffel constataram que "uma sequência presente 10 vezes nos dados de treinamento é, em média, gerada ~1000 vezes mais que uma sequência presente apenas uma vez" (Kandpal et al., 2022).

As quase-cópias exigem uma medida de similaridade. Broder definiu a resemblance de dois documentos como a similaridade de Jaccard de seus conjuntos de shingles, as sequências sobrepostas de caracteres ou palavras de um texto. Ele mostrou que amostrar os menores shingles sob uma permutação aleatória fornece uma estimativa não viesada dessa resemblance (Broder, 1997). Tomar o menor shingle sob cada uma de muitas permutações gera uma assinatura MinHash, que estima a similaridade de dois textos sem comparar seus conjuntos (Mining of Massive Datasets, seção 3.3).

lib.ai_data.deduplicate remove primeiro as cópias exatas, por SHA-256 do texto com maiúsculas e minúsculas unificadas e com sequências de espaços em branco reduzidas a um. Compara o que sobra como conjuntos de shingles de 5 caracteres com MinHash e MinHashLSH do datasketch, que retorna pares candidatos, e confirma cada candidato pela sua similaridade de Jaccard exata. Um par confirmado com 0.8 ou mais é um quase-duplicado, a menos que difira apenas em um nome, e de cada grupo de duplicatas permanece o registro com o menor ID de avaliação. A etapa de duplicatas roda sobre as avaliações pseudonimizadas, e cada estágio informa o que removeu:

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 Aprovado
"""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)
Saídapython 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

A maior parte do corpus se repete. Das 436 avaliações lidas, 78% repetem outra: 340 são cópias exatas, e restam apenas 96 textos distintos. Isso se deve sobretudo ao gerador, que monta as avaliações a partir de um punhado de frases fixas, então meça a proporção no seu próprio texto antes de treinar com ele.

O texto mais repetido, "Clear explanations and good exercises.", aparece sozinho 56 vezes.

O MinHash então confirma 8 pares com 0.8 ou mais, como duas avaliações com similaridade de 0.81 que diferem apenas no pseudônimo do instrutor. Desses pares, 8 diferem apenas em um nome, e a plataforma os mantém separados, de modo que os quase-duplicados removem 0.

Por que pares que diferem apenas em um nome permanecem separados depende do que um único limiar significa em comprimentos diferentes. Compare as avaliações do corpus com os nomes como estão escritos, com pseudônimos com chave e com marcadores simples, e depois separe cada par de textos distintos conforme difira apenas em um nome:

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 Aprovado
"""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)
Saídapython 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].

Quais pares chegam a 0.8 depende do que ocupa o lugar de cada nome. Com os nomes como estão escritos, 10 pares chegam a 0.8, e com pseudônimos com chave 8, pois um pseudônimo é mais longo que a maioria dos primeiros nomes e, assim, ocupa uma fatia maior de uma avaliação curta. Com marcadores simples, os 21 textos distintos contêm 0.

Entre os textos pseudonimizados, 459 pares diferem apenas no pseudônimo que contêm, com similaridades de 0.68 to 0.83, e o limiar os separa apenas pelo comprimento: os abaixo de 0.8 têm 66 to 78 caracteres, e os de 0.8 ou mais têm 116 to 119 caracteres.

Assim, a tarefa, e não o limiar, decide se tais avaliações são duplicatas: para um modelo que aprende como os alunos descrevem os cursos, elas são, e para um que aprende o que os alunos dizem sobre cada instrutor, não são. O assistente da plataforma responde sobre cada curso e seu instrutor, então name_only_pairs_are_duplicates = false em governance/ai_data.toml, e deduplicate nunca funde dois textos que são iguais depois que seus pseudônimos viram marcadores. O limiar decide os demais pares. O mais semelhante deles, com 0.66, é uma avaliação com e sem a sua frase sobre o instrutor: duas avaliações diferentes. A plataforma mantém 0.8, acima desse par, com uma margem.

Deduplicar pelo texto funde avaliações de cursos diferentes em um único registro, sob o ID de avaliação e o curso da primeira avaliação, de modo que o corpus mantém 96 registros, e 23 deles representam avaliações de vários cursos. Para o treinamento isso é o objetivo, pois o modelo aprende com o texto. Para fundamentar uma resposta sobre um curso, isso custa revocação, assunto que a seção de proveniência aborda.

Regra prática: Deduplique o texto de treinamento em duas etapas, cópias exatas por um hash do texto normalizado e depois quase-duplicatas por MinHash, cada uma confirmada pela sua similaridade exata, e informe quanto cada etapa removeu. Pseudonimize primeiro, para que nenhum nome chegue à comparação ou às assinaturas e a comparação possa identificar quais pares diferem apenas em um nome. Mantenha esses pares separados quando o sentido do texto depender de quem ele nomeia, e compare com marcadores quando não depender. Escolha o limiar lendo os pares próximos acima e abaixo dele no seu próprio texto.

Ajuste o LSH para recall, depois confirme cada par

Última alteração na edição 2026.11.31

Assinaturas MinHash tornam cada comparação barata; o hashing sensível à localidade (LSH) evita a maioria das comparações. O LSH divide cada assinatura em b bandas de r linhas, e dois textos se tornam um par candidato quando todas as linhas de qualquer uma das bandas coincidem. Leskovec, Rajaraman e Ullman derivam a probabilidade de que um par com similaridade de Jaccard s se torne um par candidato (Mining of Massive Datasets, capítulo 3):

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

Trata-se de uma curva em forma de S: um par bem abaixo do limiar raramente é candidato, um par bem acima quase sempre é, e próximo do limiar a chance é próxima de um cara ou coroa. O limiar aproximado da curva é (1/b)^(1/r). A documentação do datasketch alerta para os dois tipos de erro: "Haverá falsos positivos - conjuntos que não satisfazem seu limiar, mas são retornados, e falsos negativos - conjuntos qualificados que não são retornados" (datasketch, MinHash LSH).

Com 96 textos distintos, a plataforma pode se dar ao luxo de comparar exatamente cada par, 4,560 pares, e isso fornece os pares exatos contra os quais medir o LSH. O LSH enxerga apenas a similaridade, portanto precisa retornar todo par a partir de 0.8, independentemente do que a regra de nomes decida depois. Avalie o LSH contra a comparação exata, ajustado para 0.8 e ajustado para valores menores, cada um sob o hashing padrão do datasketch e sob o hashing que ele usava antes do lançamento da versão 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 Aprovado
"""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)
Saídapython 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, o LSH padrão do datasketch retorna 36 pares candidatos, deixa de encontrar 7 dos 8 pares que atingem 0.8 e, assim, confirma apenas 1 deles.

A fórmula explica o motivo. Com as 9 bandas de 13 linhas que o datasketch escolheu, um par com similaridade 0.8 se torna candidato com probabilidade de 0.40, e um com 0.9 com probabilidade de 0.93; o limiar aproximado é 0.84, acima do limiar pedido.

Sob o esquema padrão, ajustado para 0.6, o LSH encontra todos os pares e retorna 381 candidatos. Cada candidato custa uma comparação exata, contra 4,560 para comparar todos os pares, e a comparação exata descarta todo par abaixo de 0.8. Por isso a plataforma ajusta o LSH para 0.6 e confirma em 0.8, ambas as configurações em governance/ai_data.toml.

A versão 2.0.0 do datasketch tornou affine32 o esquema de permutação padrão do MinHash, e suas notas de lançamento informam que os valores de hash diferem das versões anteriores, por isso recomendam reconstruir as assinaturas e os índices LSH persistidos, ou passar MinHash(..., scheme="legacy"). Com o esquema legado, o LSH ajustado para 0.8 retorna 52 candidatos e confirma 6, de modo que uma contagem registrada sob um esquema não se reproduz sob o outro.

Ajustados para 0.6, ambos os esquemas encontram todos os 8 pares. Com recall alto e uma verificação exata, o resultado depende da similaridade, não das funções de hash.

O datasketch se recusa a misturar esquemas em um mesmo índice, com MinHash scheme 'legacy' does not match scheme 'affine32' of the MinHash previously given to this index, mas não impede que você compare contagens antigas com novas. Os exemplos do livro fixam o datasketch em 2.0.0 e escrevem scheme = "affine32" nas configurações, de modo que uma atualização não possa alterar uma contagem registrada sem uma mudança revisada.

Regra prática: Ajuste o LSH abaixo do seu limiar de similaridade, de modo que ele deixe escapar poucos pares, e confirme cada candidato pela sua similaridade exata. Meça os erros do LSH contra uma comparação exaustiva em uma amostra do seu corpus sempre que suas configurações, sua biblioteca ou o texto mudarem. Fixe a biblioteca MinHash, escreva seu esquema de hashing nas configurações e nunca compare contagens ou assinaturas armazenadas feitas sob esquemas diferentes.

Mantenha a proveniência em cada registro

Última alteração na edição 2026.11.27

Um registro que não pode ser rastreado até a sua fonte não pode ser verificado, corrigido nem removido. A proveniência no nível do registro responde a três perguntas: de qual tabela ele veio, de qual linha, e qual execução de qual job o colocou no corpus. O capítulo 4 fornece à plataforma a última parte: cada execução de um job envia eventos do OpenLineage, com um ID de execução derivado do horário da execução e do nome do job, e a linhagem de colunas extraída do SQL do job.

lib.ai_data.build grava cada registro com a sua proveniência ao lado das colunas próprias da avaliação: source_table, review_id, job e run_id. Ele envia os eventos de execução do job com lib.lineage.record. Uma escolha ali é importante: a linhagem é extraída da consulta como a camada de imposição a executou, com o filtro de consentimento e a máscara nela, e não do SQL em pipelines/review_corpus.sql. Construa o corpus e, em seguida, siga um registro até a sua execução:

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 Aprovado
"""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)}")
Saídapython 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 um registro até a origem mostra o que a linhagem precisa registrar. O registro "Too fast in the second half. <PERSON_85783bac> explains things well." veio de learning.reviews, avaliação 18, escrito pelo job platform/review_corpus, e o seu run_id é a execução do evento COMPLETE do job.

Essa execução leu crm.learners, learning.courses, learning.reviews, e a linhagem dela diz que as linhas foram filtradas por crm.learners.ai_training_consent, learning.reviews.learner_id, as entradas INDIRECT que decidem quais linhas existem, e que body é um TRANSFORMATION do texto da avaliação.

Analisada a partir do SQL do pipeline como escrito, as linhas do mesmo job são filtradas por nothing, e body é uma cópia IDENTITY. Isso indicaria que o texto pessoal foi copiado sem alterações, sem que a coluna de consentimento tenha participado. A consulta como foi executada é o que de fato aconteceu, por isso é isso que a linhagem registra.

A proveniência torna o corpus verificável depois do fato. Ao juntar cada registro, por meio de learning.reviews, ao seu autor, encontram-se 96 of 96 registros cujo autor deu consentimento, uma verificação que a plataforma pode executar em qualquer build antigo contra as respostas de hoje.

A proveniência também permite que a recuperação respeite as permissões de cada leitor. A OWASP pede que as aplicações construídas sobre modelos de linguagem "Implementem controles de acesso refinados e armazenamentos de vetores e embeddings com reconhecimento de permissões" (OWASP LLM08:2025). A plataforma responde a uma pessoa a partir de um índice construído a partir deste corpus, o que mantém o review_id de cada registro junto dos seus vetores. Antes que um registro recuperado chegue ao modelo, a camada de recuperação pergunta à camada de imposição, em nome da pessoa que recebe a resposta, quais dessas avaliações ela pode ler, do mesmo modo como o capítulo 6 executa as consultas de um assistente, e descarta as demais. Assim, um instrutor recebe apenas registros dos seus próprios cursos. Um registro que representa avaliações de vários cursos carrega o ID da primeira avaliação, por isso a verificação falha de forma restritiva: para cada um dos 23 registros desse tipo, ela pode ocultar um texto que a pessoa poderia ter lido, e nunca mostra um que ela não poderia.

Regra prática: Dê a cada registro a sua tabela de origem, o ID da linha de origem, e o job e a execução que o gravaram, e registre a linhagem do job a partir da consulta como ela foi executada, com filtros e máscaras incluídos. Verifique os builds antigos contra o consentimento atual por meio dessa proveniência. Filtre cada recuperação pela decisão própria do leitor sobre a linha de origem de cada registro, antes que um modelo a veja.

Gere o cartão de dados a partir da execução

Última alteração na edição 2026.11.27

Um cartão de dados informa a quem treina ou audita um modelo o que há nos dados dele, de onde vieram e o que foi feito com eles. Croissant é o formato de metadados da MLCommons para conjuntos de dados de aprendizado de máquina (Akhtar et al., 2024). A especificação 1.1 do Croissant torna o cartão verificável: "Conjuntos de dados Croissant devem declarar que estão em conformidade com o esquema versionado, por exemplo http://mlcommons.org/croissant/1.1", e todo conjunto de dados deve informar descrição, licença, nome, URL, criador e data de publicação. Para proveniência, a especificação recomenda a Ontologia PROV do W3C (PROV-O) (Croissant 1.1). Seu vocabulário de IA responsável acrescenta propriedades como rai:dataCollection e rai:personalSensitiveInformation (Croissant RAI 1.0). Um cartão escrito à mão descreve os dados que alguém pretendia construir; um cartão gerado pela execução descreve os dados que ela de fato construiu.

lib.ai_data.card gera o cartão da plataforma com o mlcroissant 1.1.1, a biblioteca Python da MLCommons para Croissant. A execução fornece as contagens, o SHA-256 do arquivo do corpus, um campo para cada coluna e três propriedades PROV-O: as tabelas que o próprio SQL do pipeline lê, de onde vêm os valores, como prov:wasDerivedFrom; a tabela que a reescrita da camada de imposição acrescenta, que apenas decide quais linhas existem, como prov:wasInfluencedBy; e a execução, como prov:wasGeneratedBy. O mlcroissant grava essas propriedades pelo argumento extra_properties, mas não acrescenta o prefixo prov ao contexto do cartão, então o módulo o acrescenta. O criador é o responsável por ai.review_corpus em governance/metadata.toml. A licença, o nome, a URL, a descrição e os casos de uso vêm de governance/ai_data.toml, e lib.ai_data.card_problems é a verificação própria da plataforma sobre o resultado. Gere o cartão, primeiro com o conformsTo padrão do 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 Aprovado
"""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)
Saídapython 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

Com o padrão, o mlcroissant grava http://mlcommons.org/croissant/1.0, embora o seu próprio LATEST_VERSION seja 1.1 (código-fonte do mlcroissant), de modo que o cartão declararia uma versão para a qual não foi escrito. A plataforma grava http://mlcommons.org/croissant/1.1, http://mlcommons.org/croissant/RAI/1.0.

O datePublished do cartão, 2026-10-01T02:00:00Z, é o horário da compilação, porque a plataforma publica um cartão somente com a compilação que ele descreve. Sua version, 20261001.0.0, usa a data da compilação como número principal. O Croissant recomenda MAJOR.MINOR.PATCH, em que uma nova versão major significa "os dados existentes foram alterados (editados, removidos ou com registros embaralhados entre as divisões)", e qualquer compilação noturna pode remover registros.

O cartão nomeia as fontes iceberg://platform/learning.courses, iceberg://platform/learning.reviews, a influência iceberg://platform/crm.learners e a atividade platform/review_corpus, e lista as etapas de pré-processamento com as contagens da execução.

Os avisos que o mlcroissant emite, 1 ao todo, referem-se a propriedades recomendadas, aqui citeAs, e não ao problema que a verificação da plataforma encontra: creator está ausente. ai.review_corpus não tem responsável no arquivo de metadados, a lacuna que o capítulo 2 encontrou, então o cartão permanece não publicado até que a tabela tenha um responsável. O capítulo 10 relata a mesma lacuna em toda execução, como um achado já presente na main.

O mlcroissant também consegue ler um cartão de volta, com mlc.Dataset, mas na versão 1.1.1, com rdflib 7.6.0 e pandas 3.1.1, a leitura emite um DeprecationWarning do rdflib e um Pandas4Warning, e devolve os campos de texto como bytes. Por isso, os exemplos do livro apenas gravam cartões e os verificam com o próprio código da plataforma.

Regra prática: Gere o cartão na execução que constrói os dados, com cada contagem, hash, fonte e versão tirados dessa execução, e escreva por extenso a versão do formato. Verifique o cartão com o seu próprio código para cada propriedade que a especificação exige, já que o validador da biblioteca não relata todas, e não publique nem treine com um corpus cujo cartão falhe.

Cite o que o Ato de IA da UE diz sobre dados de treinamento

Última alteração na edição 2026.11.27

O Ato de Inteligência Artificial da União Europeia, Regulamento (UE) 2024/1689, trata dos dados de treinamento em vários pontos. Esta seção cita dois deles, o artigo 10 e o artigo 53(1)(d), e não os interpreta.

Para sistemas de IA de alto risco, o artigo 10(2) estabelece que os conjuntos de dados de treinamento, validação e teste "estão sujeitos a práticas de governança e gestão de dados", e lista os aspectos que essas práticas abrangem. Eles incluem os processos de coleta de dados e a origem dos dados, com a finalidade original da coleta de dados pessoais, e a preparação dos dados, como anotação, rotulagem, limpeza, atualização, enriquecimento e agregação (Ato de IA).

O artigo 10(3) exige conjuntos de dados "relevantes, suficientemente representativos e, na medida do possível, isentos de erros e completos tendo em vista a finalidade prevista" (Lei de IA).

O Regulamento (UE) 2026/1744, o Ômnibus Digital sobre IA, publicado em 24 de julho de 2026, mantém essas passagens como citadas. Ele substitui os parágrafos 1 e 6 do artigo 10, suprime o parágrafo 5 e insere um artigo 4a, "Tratamento de categorias especiais de dados pessoais para detecção e correção de vieses". Ele também define quando o Capítulo III, Seções 1 a 3, que incluem o artigo 10, passa a ser aplicável: a partir de 2 de dezembro de 2027, para sistemas de IA de alto risco classificados nos termos do artigo 6(2) e do Anexo III, e a partir de 2 de agosto de 2028, para os classificados nos termos do artigo 6(1) e do Anexo I (Regulamento (UE) 2026/1744).

Para os fornecedores de modelos de IA de uso geral, o artigo 53(1)(d) exige que eles "elaborem e disponibilizem publicamente um resumo suficientemente detalhado sobre o conteúdo utilizado para o treinamento do modelo de IA de uso geral, de acordo com um modelo fornecido pelo Escritório de IA". A Comissão Europeia publicou esse modelo como C(2025) 8311 (modelo da Comissão, PDF).

Sua nota explicativa afirma que uma entidade a jusante que modifica um modelo já colocado no mercado da União pode tornar-se fornecedor do modelo resultante, nos termos das diretrizes da Comissão sobre modelos de IA de uso geral que a nota menciona. Nesse caso, a entidade que faz a modificação informa apenas o conteúdo de treinamento usado na modificação. O Anexo III do Ato tem o título "Sistemas de IA de alto risco referidos no artigo 6(2)", e seu ponto 3, "Educação e formação profissional", inclui "(b) sistemas de IA destinados a ser utilizados para avaliar os resultados da aprendizagem, inclusive quando esses resultados sejam utilizados para orientar o processo de aprendizagem de pessoas singulares em instituições de ensino e formação profissional de todos os níveis" (Lei de IA). Citamos esse trecho porque a plataforma é uma plataforma educacional, e paramos por aí. Saber se algum sistema da plataforma é de alto risco nos termos do artigo 6 é outra questão, e nenhum código deste capítulo depende da resposta.

Regra prática: Cite a lei conforme alterada, a partir do Jornal Oficial, com um link e a data em que você a consultou, porque o Ômnibus alterou tanto o texto quanto as datas. Mantenha a lei fora da lógica do seu pipeline: gere os fatos do cartão a partir da execução, e deixe que as pessoas que respondem a questões jurídicas decidam quais passagens se aplicam.

O que dá errado em produção

Última alteração na edição 2026.11.27

Um corpus não avisa de nada. O modelo é treinado, o cartão do modelo (model card) é publicado, e os problemas aparecem depois, no que o modelo diz ou em uma solicitação que ninguém consegue atender.

Um aluno retira o consentimento depois da build

Última alteração na edição 2026.11.27

Assim como a lista do marketing no capítulo 7, um corpus registra quem tinha consentido no dia em que foi gerado. Pegue o corpus que lib.ai_data.build grava na execução noturna de 1º de outubro, a build de 1º de outubro, e retire o consentimento do autor de um dos seus registros. Em seguida, gere novamente o corpus na mesma pasta na noite seguinte, sem gerar outra vez a sua ficha, e verifique cada build contra o consentimento de hoje, como uma execução de treinamento faz antes de começar:

A build de 1º de outubro contém 1 registro desse aluno, e a build de 2 de outubro contém 0, de modo que o corpus seguinte deixa o aluno de fora. As duas builds são execuções diferentes, com IDs de execução próprios. A próxima execução de treinamento também precisa deixar o aluno de fora, e o mesmo vale para o próximo índice.

Verificada pela proveniência contra as respostas de hoje, a build de 1º de outubro tem 95 of 96 registros cujo autor consente, de modo que uma execução de treinamento que faça a verificação a recusa. A build de 2 de outubro passa com 95 of 95.

O que foi feito a partir da build de 1º de outubro antes da retirada mantém o que foi revisado: uma cópia do seu arquivo, um índice construído a partir dele, um modelo ajustado com ele. O Comitê Europeu para a Proteção de Dados considera que "modelos de IA treinados com dados pessoais não podem, em todos os casos, ser considerados anônimos" (Parecer 28/2024 do EDPB).

O artigo 7(3) do RGPD garante o direito de retirar o consentimento a qualquer momento. Ele diz que a retirada não afeta a licitude do tratamento baseado no consentimento anterior à retirada, que a pessoa deve ser informada desse direito antes de dar o consentimento, e que retirar não pode ser mais difícil do que dar (RGPD). O capítulo 7 cita as primeiras frases desse mesmo artigo e explica o que a retirada muda no código da plataforma.

A parte do código é encontrar, pela proveniência, cada build que contém o registro e, pelo ID de execução, cada modelo e índice feito a partir dessas builds. Depois, ela lê o que acontece com eles a partir de [legal.withdrawal] em governance/ai_data.toml. A resposta da equipe jurídica para um modelo feito a partir da build de 1º de outubro é undecided, um marcador sob o qual a tarefa lista esses modelos para a equipe jurídica e não altera nada. Se a resposta for que um modelo não pode manter a revisão, a única forma de removê-la que podemos garantir é treinar o modelo novamente com uma build que não a contenha.

A ficha também falhou, em silêncio. A última etapa de pré-processamento ainda diz "Kept 96 records, each with its source table, review ID, job and run." O arquivo tem 95 registros, e a verificação da plataforma encontra 2 problemas: o criador ausente, e um arquivo cujo SHA-256 não é o que a ficha declara. Uma ficha que não é gerada de novo com os seus dados descreve outro conjunto de dados.

Regra prática: Registre, pelo ID de execução, a partir de qual build foi feito cada modelo e cada índice. Antes de cada execução de treinamento, verifique os registros da build contra o consentimento de hoje e o hash do arquivo contra a sua ficha, e recuse qualquer build que falhe em um dos dois. Quando um aluno retira o consentimento, encontre as builds que contêm os seus registros e os modelos feitos a partir delas, e deixe que a resposta da sua equipe jurídica na configuração decida o que acontece com eles.

Outras falhas

Última alteração na edição 2026.11.27
  • Um filtro sobre recusas que mantém os casos desconhecidos. Com ele, o corpus ficou com 2,045 avaliações em vez de 436, principalmente de estudantes que nunca foram consultados. Percebe-se o problema contando os registros do corpus por resposta de consentimento, por meio de sua proveniência: qualquer resposta diferente de sim é um defeito.
  • Dados pessoais que um modelo memoriza a partir do seu texto. Carlini e colaboradores extraíram texto de treinamento de um modelo de linguagem, incluindo informações pessoais públicas, como nomes, números de telefone e endereços de e-mail, mesmo quando cada uma dessas sequências aparecia em um único documento (Carlini et al., 2021). O corpus do pipeline simples contém 120 e-mails rotulados, 113 deles distintos e 106 escritos apenas uma vez, e duplicatas repetem, em cada cópia, o que um detector deixou passar. Meça o que sobra em amostras rotuladas do seu próprio texto e remova duplicatas antes do treinamento.
  • Uma chave de pseudônimos que vaza. Com a chave do corpus e uma lista de nomes de instrutores, qualquer pessoa pode calcular todos os pseudônimos do corpus. Quando a chave puder ter vazado, troque-a, reconstrua todos os corpora feitos com ela e localize, pelo ID da execução, as cópias e os modelos produzidos a partir de builds com a chave antiga, como em uma retirada.

O que este capítulo decidiu

Última alteração na edição 2026.11.27
  • O corpus é construído pela camada de imposição, como analyst-1 para ai-training: somente revisões cujo ai_training_consent do autor é verdadeiro, contatos mascarados, e um consentimento desconhecido contado como não.
  • Toda resposta jurídica de que o código precisa é um valor provisório (placeholder) para a equipe jurídica em [legal] em governance/ai_data.toml: o consentimento que admite um registro, a licença do cartão e o que acontece com modelos criados antes de uma retirada.
  • Dados pessoais são detectados depois das máscaras da camada de aplicação, com os reconhecedores de padrões e a lista de nomes de instrutores da equipe de plataforma, e substituídos por pseudônimos com chave. O Privacy Filter é medido, não adicionado. O corpus é pseudonimizado, nunca anonimizado.
  • Pseudônimos são HMAC-SHA256 sob a chave própria do job do corpus, não o SHA-256 sobre chave e valor da camada de aplicação, e nunca o hash com salt aleatório do Presidio.
  • Duplicatas são removidas em duas etapas, cópias exatas por SHA-256 e, depois, quase-duplicatas por MinHash LSH ajustado para 0.6 e confirmado em uma similaridade de Jaccard de 0.8, sem nunca unir textos que diferem apenas em um nome. datasketch e seu esquema, affine32, são fixados.
  • Todo registro mantém sua proveniência, source_table, review_id, job e run_id, e uma execução de treinamento verifica primeiro a sua construção contra o consentimento de hoje.
  • O cartão do conjunto de dados é o Croissant 1.1 com RAI 1.0, gerado pela execução, verificado pelo próprio código da plataforma e não publicado até que ai.review_corpus tenha um responsável.
  • Respostas sobre uma pessoa vêm de um índice do corpus, filtrado pela decisão dessa pessoa sobre a revisão de origem de cada registro.
  • O EU AI Act é citado conforme alterada e com link, nunca interpretada. Um corpus só é tão limpo quanto aquilo que foi admitido nele. Cada registro é decidido quando o corpus é construído, cada registro mantém sua origem, de modo que uma decisão pode ser rastreada até a revisão de onde veio, e o cartão diz o que foi feito com o restante.

Este capítulo, nesta edição

Edição 2026.11.31Exemplos aprovados em 19 de nov de 202610 de 10 exemplos exemplos deste capítulo passam

Traduzido do livro em inglês, edição 2026.11.31.

Citar esta seção

Formato

Cada formato cita o livro em inglês, que esta tradução acompanha.

Todos os formatos citam esta edição. Seu link abre a edição atual, em que o título de cada seção indica quando seu texto foi alterado pela última vez. As datas de acesso e de recuperação são o dia em que você abre esta página.

Nesta página

Capítulo 9 de 10: Governança de dados para IA

  1. Admita apenas avaliações cujos autores consentiram
  2. Substitua os dados pessoais no texto, depois meça o que sobrou
  3. Mantenha os pseudônimos consistentes com um hash com chave
  4. Encontre quase-duplicatas com MinHash
  5. Ajuste o LSH para recall, depois confirme cada par
  6. Mantenha a proveniência em cada registro
  7. Gere o cartão de dados a partir da execução
  8. Cite o que o Ato de IA da UE diz sobre dados de treinamento
  9. O que dá errado em produção
  10. Um aluno retira o consentimento depois da build
  11. Outras falhas
  12. O que este capítulo decidiu

Voltar ao topoTodos os capítulos