Use Natural Language Framework for redaction

[eonist]

let text = "John Doe lives in New York."
let tagger = NLTagger(tagSchemes: [.nameType])
tagger.string = text

tagger.enumerateTags(in: text.startIndex..<text.endIndex, unit: .word, scheme: .nameType) { tag, tokenRange in
    if tag == .personalName || tag == .placeName {
        // Redact the sensitive information
        text.replaceSubrange(tokenRange, with: "[REDACTED]")
    }
    return true
}

[eonist]

let tagger = NLTagger(tagSchemes: [.nameType, .lexicalClass, .customSensitiveDataScheme])
let modelURL = Bundle.main.url(forResource: "SensitiveDataModel", withExtension: "mlmodelc")!
let customModel = try! NLModel(mlModel: MLModel(contentsOf: modelURL))
tagger.setModels([customModel], forTagScheme: .customSensitiveDataScheme)

[eonist]

tagger.string = inputText
tagger.enumerateTags(in: inputText.startIndex..<inputText.endIndex, unit: .word, scheme: .customSensitiveDataScheme) { tag, tokenRange in
    if let tag = tag {
        switch tag.rawValue {
        case "PASSWORD":
            // Handle password
        case "BANKACCOUNT":
            // Handle bank account number
        case "SEEDPHRASE":
            // Handle seed phrase
        default:
            break
        }
    }
    return true
}

[eonist]

convert to CoreML models:

import coremltools as ct

# Convert your trained model to Core ML format
coreml_model = ct.convert(your_trained_model, inputs=[ct.TensorType(shape=input_shape)])

# Save the Core ML model
coreml_model.save("your_model.mlmodel")

[eonist]

DeepPass: A deep learning approach for finding passwords in text4. This model uses neural networks to identify potential passwords within extracted text.

[eonist]

For more complex scenarios, consider using libraries like Microsoft's Presidio, which provides pre-trained models for recognizing various types of sensitive data without requiring direct training on sensitive information

[eonist]

Training models to identify sensitive data presents several significant challenges:

1. Data Privacy Risks: Training on real sensitive data can lead to privacy violations and potential exposure of confidential information[1][3].

2. Model Memorization: AI models might inadvertently memorize sensitive parts of the training data, making it possible for attackers to extract this information later[1].

3. Data Quality Issues: Poor quality data can result in unreliable or biased models, which is particularly problematic when dealing with sensitive information[3].

4. Complexity of Unstructured Data: Accurately detecting sensitive data in unstructured formats is challenging, often leading to false positives and noise when using simplistic methods[2].

5. Identifying Uncommon Identifiers: Classification solutions must be able to detect less common or proprietary personal identifiers, such as product serial numbers or GPS locations that could indirectly identify individuals[2].

6. Security Vulnerabilities: AI systems processing sensitive data are attractive targets for cyberattacks, including data poisoning attempts[3].

7. Scalability and Performance: Efficiently handling large volumes of sensitive data for training and classification can be technically challenging[3].

8. Lack of Transparency: Complex AI models can be difficult to interpret, making it hard to understand how they identify sensitive data and potentially hindering accountability[4].

To address these challenges, approaches such as using anonymized datasets, implementing robust data governance processes, leveraging advanced machine learning techniques for context understanding, and ensuring strong security measures are crucial. However, it's important to note that the safest approach is often to limit the collection and storage of sensitive data in the first place, rather than relying solely on AI models for detection.

Citations:
[1] https://fastdatascience.com/natural-language-processing/sensitive-data-machine-learning-model/
[2] https://www.sentra.io/learn/5-data-classification-challenges-that-security-teams-face
[3] https://dialzara.com/blog/ai-data-lifecycle-management-6-key-challenges/
[4] https://provost.wsu.edu/challenges-of-ai/

[eonist]

Yes, there are several open-source models and tools available for detecting sensitive information:

1. Presidio: An open-source system that offers detection and anonymization of private entities in text, including credit card details, names, locations, social security numbers, and financial data[5].

2. Databunker: An open-source scheme designed to simplify GDPR and CPRA compliance, providing APIs for easy implementation and secure storage of PII[5].

3. DataHub: An open-source unified sensitive data discovery, observability, and governance platform developed by Acryl Data and LinkedIn[4].

4. Nightfall: While not entirely open-source, Nightfall offers a free tier that allows scanning of public or private repositories for credentials and PII, with up to 100 scans per month[4].

5. Apache Atlas and Marquez: These are mentioned as open-source sensitive data discovery tools, although specific details are not provided in the search results[4].

6. OpenDLP and Piiano Vault - ReDiscovery: Also listed as open-source tools for sensitive data discovery[4].

It's important to note that while these tools exist, their effectiveness may vary, and they often require fine-tuning or customization for specific use cases. For instance, some researchers suggest that fine-tuning a 7B parameter model could be effective for named entity recognition in specific document types[1]. Additionally, companies like Patronus AI are developing datasets like EnterprisePII to improve LLMs' ability to detect business-sensitive information[2].

Citations:
[1] https://www.reddit.com/r/LocalLLM/comments/1b68dx5/seeking_recommendations_for_new_open_source_llms/
[2] https://www.databricks.com/blog/patronus-ai-using-llms-to-detect-business-sensitive-information
[3] https://www.capitalone.com/tech/open-source/sensitive-data-detection-with-data-profiler/
[4] https://research.aimultiple.com/open-source-sensitive-data-discovery/
[5] https://www.edenai.co/post/top-free-anonymization-tools-apis-and-open-source-models
[6] https://granica.ai/blog/pii-data-discovery-tools-grc

[eonist]

https://github.com/piiano and https://www.piiano.com/
https://github.com/ezarko/opendlp
https://github.com/microsoft/presidio
https://github.com/likedan/Awesome-CoreML-Models
https://github.com/john-rocky/CoreML-Models
https://github.com/securitybunker/databunker and https://github.com/securitybunker/databunker-store

[eonist]

Presidio can help identify sensitive/PII data in un/structured text

[eonist]

Apple's Natural Language Processing Framework: While not specifically designed for redaction, it can be used as a foundation for building an on-device redaction system. It offers capabilities like named entity recognition that could be adapted for identifying sensitive information.

MLKit for Android: Google's on-device machine learning SDK for Android includes text recognition and language identification, which could be used as building blocks for a redaction system.

Custom Core ML Models: For iOS, developers can create and deploy custom NLP models using Core ML, which runs entirely on-device.

TensorFlow Lite: This framework allows running lightweight machine learning models on mobile devices, which could be used to create a custom on-device redaction solution.

[eonist]

However, it's important to note that fully-featured, out-of-the-box solutions for on-device sensitive data redaction are not common. Most existing solutions that claim to be "on-device" often still require some level of cloud processing or are actually on-premises solutions rather than truly mobile on-device options.

Developers looking to implement such a system would likely need to build a custom solution using these on-device machine learning frameworks as a foundation.

[eonist]

https://developer.apple.com/documentation/coreml/reducing-the-size-of-your-core-ml-app

[eonist]

Custom Core ML models can vary significantly in size, ranging from a few megabytes to hundreds of megabytes. A typical custom Core ML model can be around 65-150 MB[3][4]. However, there are several techniques to reduce the size of these models:

1. Quantization: This technique can reduce model size by up to 50-66% without significant loss in accuracy[1][3]. For example:

   • A 65 MB model can be reduced to 33 MB using 16-bit quantization[3].
   • Quantizing to 16-bit can reduce models by about 40%[1].

2. Transfer Learning: This approach can make models up to 5 times smaller. A 65 MB model could be reduced to just 7 MB using transfer learning[3].

3. Architecture Selection: Choosing a more suitable architecture for mobile devices can significantly reduce model size[4].

4. Flexible Input/Output Sizes: This technique doesn't directly reduce model size but can eliminate the need for multiple models of different sizes[2].

It's important to note that the actual size of a custom Core ML model depends on various factors, including the complexity of the task, the architecture used, and the techniques applied to optimize the model.

Citations:
[1] https://reza.codes/2018-06-12/reducing-the-size-of-a-trained-coreml-model-a-deep-dive-into-quantization/
[2] https://fritz.ai/advanced-tips-for-core-ml/
[3] https://developer.apple.com/videos/play/tech-talks/10155/
[4] https://stackoverflow.com/questions/52347827/download-custom-coreml-model-and-load-for-usage-swift
[5] https://apple.github.io/coremltools/docs-guides/source/mlmodel.html
[6] https://developer.apple.com/documentation/coreml/model-customization
[7] https://developer.apple.com/documentation/coreml/reducing-the-size-of-your-core-ml-app