Develop a PII Removal Module for a Mental Health Care WhatsApp Chatbot

[anjineyulutv]

Here's a task for students to create a mental health care WhatsApp chatbot that removes personally identifiable information (PII):

Task: Develop a PII Removal Module for a Mental Health Care WhatsApp Chatbot

Objective:
Create a module for a WhatsApp chatbot that can identify and remove personally identifiable information (PII) from user messages before processing them. This will help protect user privacy and ensure compliance with data protection regulations.

Requirements:

1. Implement a function that takes a user message as input and returns the message with PII removed.
2. Identify and remove the following types of PII:
   • Names
   • Phone numbers
   • Email addresses
   • Physical addresses
   • Social security numbers
   • Date of birth
   • Credit card numbers
3. Replace identified PII with appropriate placeholders (e.g., [NAME], [PHONE], etc.).
4. Ensure the function can handle various formats and variations of PII.
5. Maintain the overall structure and meaning of the message while removing PII.

Suggested libraries and techniques:

1. Natural Language Processing (NLP) libraries:

   • spaCy: For named entity recognition and text processing
   • NLTK (Natural Language Toolkit): For tokenization and text analysis

2. Regular expressions (regex):

   • Python's built-in 're' module for pattern matching

3. Machine learning techniques:

   • Named Entity Recognition (NER) models
   • Custom-trained models for specific PII types

4. PII-specific libraries:

   • presidio-analyzer and presidio-anonymizer: Microsoft's open-source PII detection and anonymization libraries

5. Text preprocessing techniques:

   • Tokenization
   • Lowercasing
   • Removing punctuation and special characters

6. Data structures:

   • Dictionaries for storing and mapping PII types to placeholders

7. Testing frameworks:

   • unittest or pytest for creating comprehensive test cases

Here's a basic outline to get students started:

import re
import spacy

class PIIRemover:
    def __init__(self):
        self.nlp = spacy.load("en_core_web_sm")
        self.pii_patterns = {
            'PHONE': r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b',
            'EMAIL': r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
            'SSN': r'\b\d{3}-\d{2}-\d{4}\b',
            # Add more patterns for other PII types
        }

    def remove_pii(self, text):
        # Use spaCy for named entity recognition
        doc = self.nlp(text)
        
        # Replace named entities with placeholders
        for ent in doc.ents:
            if ent.label_ in ['PERSON', 'ORG', 'GPE']:
                text = text.replace(ent.text, f"[{ent.label_}]")
        
        # Use regex for other PII types
        for pii_type, pattern in self.pii_patterns.items():
            text = re.sub(pattern, f"[{pii_type}]", text)
        
        return text

# Example usage
pii_remover = PIIRemover()
original_text = "Hi, I'm John Doe. My phone is 123-456-7890 and my email is john@example.com."
cleaned_text = pii_remover.remove_pii(original_text)
print(cleaned_text)

By working on this task, students will gain experience in NLP, regex, data privacy, and building practical applications for mental health care. They'll also learn about the importance of protecting user data in sensitive applications.

[luv-singh-ai]

Hey Anjineyulu, thanks for starting this discussion.

Students are expected to try different methods and come up with best method they can get. Feel free to ask any question on this discussion for the same.

You can start from this dataset - https://drive.google.com/file/d/11wZFqqdgM3r3idPWuXPUdeqMrSHtVs-m/view?usp=sharing

It contains 4434 generated texts with their corresponding annotated labels in this format

Description:

document (str): ID of the essay
full_text (string): AI generated text.
tokens (string): a list with the tokens (comes from text.split())
trailing_whitespace (list): a list with boolean values indicating whether each token is followed by whitespace.
labels (list): list with token labels in BIO format

Note: (source:https://www.kaggle.com/datasets/alejopaullier/pii-external-dataset)

[luv-singh-ai]

For Hinglish Dataset, use this dataset: https://github.com/skmanish/hinglish-conv-dataset/tree/32eb99c7a880cbc7d700cf61a378999959e7d334/conversations

[luv-singh-ai]

@anjineyulutv Can we explore Differential Privacy and Homomorphic encryption?

[anjineyulutv]

Sure

[shravankshenoy]

Hey everyone, I did a bit of research on this and as mentioned above, found that Presidio has a lot of functionalities which we can use and modify for this. The code below is a brief example of how we can do this. Presidio has a bunch of inbuilt entities and we can add our own entities, rules and models

Points to Note

1. The code replaces identified PII with appropriate placeholders, but Presidio also gives options to mask and redact if required

2. For Hinglish data, one potential approach could be to use a language detection library like langdetect (https://github.com/Mimino666/langdetect) to detect the language before applying the pii detection and redaction. Infact the same thing has been discussed at How to deal with different languages microsoft/presidio#373

3. For evaluating the PII detection system, we can use metrics like precision, recall, F1 score, like shown in this notebook (https://github.com/microsoft/presidio-research/blob/master/notebooks/4_Evaluate_Presidio_Analyzer.ipynb). We could potentially create our own functions for evaluation, taking inspiration from this code: https://github.com/microsoft/presidio-research/blob/master/presidio_evaluator/evaluation/evaluator.py

4. Presidio stores detailed information about each PII entity like character start and end, entity type, etc

Code

PFB the sample code. The Jupyter notebook for the same is https://colab.research.google.com/drive/18qzbCMq8S55g4QMGLf1qMgksXyVkTflu?usp=sharing

# inbuilt entities
pii_entities = [
    "PERSON",
    "PHONE_NUMBER",
    "EMAIL_ADDRESS",
    "LOCATION",
    "IN_PAN",
    "IN_AADHAAR",
    "CREDIT_CARD",          
]
# add additional rules
titles_recognizer = PatternRecognizer(supported_entity="TITLE",
                                      deny_list=["Mr.","Mrs.","Miss"])
pii_entities.append("TITLE")

pronoun_recognizer = PatternRecognizer(supported_entity="PRONOUN",
                                       deny_list=["he", "He", "his", "His", "she", "She", "hers", "Hers"])
pii_entities.append("PRONOUN")

# detect the PII using analyzer engine
analyzer = AnalyzerEngine()
analyzer.registry.add_recognizer(titles_recognizer)
analyzer.registry.add_recognizer(pronoun_recognizer)
analyzer_results = analyzer.analyze(text=text_to_anonymize, entities=pii_entities, language='en')

print(analyzer_results)

# anonymize the data
anonymizer = AnonymizerEngine()
anonymized_results = anonymizer.anonymize(
    text=text_to_anonymize,
    analyzer_results=analyzer_results,
    operators={"DEFAULT": OperatorConfig("replace")}
)

print(f"text: {anonymized_results.text}")
print("detailed response:")
pprint(json.loads(anonymized_results.to_json()))

The final result will be

Hi, I'm <PERSON>. My phone is <PHONE_NUMBER> and my email is <EMAIL_ADDRESS>

Do let me know your thoughts on this.