📄 Automated De-Identification of Arabic Medical Records

Summary

The paper builds what it presents as the first automated pipeline for removing personal health information from Arabic clinical text. Labelled Arabic medical data is very scarce. The authors therefore built a training set by machine-translating the English i2b2 2014 de-identification corpus with Google Translate. Before translation, each sensitive span was swapped for its entity-type label, and after translation the labels were filled back in with authentic Arabic values. This kept entity boundaries intact and localized the content at the same time.

They trained two NER families inside Spark NLP for Healthcare and compared them on generic and granular label sets:

• a Bi-LSTM-CNN-Char tagger using GloVe, AraBERT or CamelBERT embeddings;
• end-to-end BERT For Token Classification (BFTC).

A regex-based Contextual Parser catches fixed-format identifiers the networks miss. An obfuscation step then masks the detected items or replaces them with fake ones. BFTC generally beat Bi-LSTM, and the full pipeline reached micro F1 between roughly 0.94 and 0.98 across 17 sensitive entity types. The authors argue this is comparable to manual expert de-identification. Because the pipeline runs on Apache Spark, it can be deployed at scale.

Key points

• Training and test data come from the i2b2 2014 de-identification corpus (CoNLL format, IOB2 tags), translated into Arabic via the Google Translate API using a placeholder-based entity-preservation trick.
• Two label schemes are used:
  • a generic one: NAME, LOCATION, AGE, DATE, CONTACT, IDs, PROFESSION;
  • a granular one, for example PATIENT vs DOCTOR and CITY vs ZIP vs HOSPITAL.
• On the generic set, Bi-LSTM macro F1 was 0.9378 with GloVe, 0.9372 with AraBERT and 0.9590 with CamelBERT. BFTC reached 0.9600 with AraBERT and 0.9700 with CamelBERT, and both BFTC variants had micro F1 of 0.98.
• ID and PROFESSION were among the weakest classes. Bi-LSTM scored roughly 0.84–0.87 on ID, and BFTC raised this to about 0.93–0.95.
• The pipeline stages are:
  1. document assembler;
  2. deep-learning sentence detector, since rule-based splitting did poorly on Arabic notes;
  3. tokenizer;
  4. embeddings;
  5. NER;
  6. Contextual Parser with prefix/suffix rules;
  7. masking or obfuscation.
• Limitations the authors acknowledge include translation noise, syntactic oddities from inserted substitutes, dialect and jargon coverage, and the need for metrics that weigh errors by how critical each entity type is.

Interesting ideas

• I1. Swapping annotated spans for type placeholders before machine translation, then refilling them afterwards, keeps labels aligned without any token-level alignment step.
• I2. The same placeholder slots can be refilled with culturally native values, which adapts a corpus to a new setting and multiplies it cheaply.
• I3. A learned tagger is paired with a configurable rule engine using prefix/suffix context, so fixed-format identifiers are handled by explicit patterns instead of retraining.
• I4. The authors maintain one dataset under two label granularities, a coarse type and its fine-grained role, and train and evaluate against both.
• I5. They propose scoring errors by how harmful each entity type is to miss, not by flat F1.

For Mova

How these ideas could serve Mova, our small open language model — its files, stages and tests:

• I1 (back): when translating through the meta-world, entities could travel as typed slots and be realized only at the end, so the mapping from graph nodes to surface text stays traceable.
• I2 (learn): refilling named slots in math word problems or fables with other names, places and quantities could produce controlled variants, and a reader whose answer shifts with irrelevant names would fail a negative control.
• I3 (tokens): dates, phone numbers, measures and IDs could be recognized by inspectable contextual rules ahead of the tagger, keeping those decisions explainable.
• I4 (world): entities could carry a coarse type plus an optional fine subtype, for example NAME → PATIENT, so reasoning can fall back to the coarse class when the fine one is uncertain.
• I5 (learn): evaluation could weight mistakes by their downstream effect on the answer, for example a wrong agent in a frame versus a wrong adjective attachment, to prioritize repairs.