Complete Technical Paper Content — Differential Privacy Ai
1. Executive Abstract, Problem Formulation & Background
Differentially private stochastic gradient descent (DP-SGD) is an algorithmic technique for learning and a refined analysis of privacy costs within the framework of differential privacy. DP-SGD was introduced by Abadi et al. at the 2016 ACM Conference on Computer and Communications Security, where it addresses a fundamental challenge—the privacy-utility trade-off. Stronger privacy requires more noise or larger privacy budgets, which can reduce model accuracy. DP-SGD has become a de facto standard for privacy-preserving learning from large datasets. It is used in domains with sensitive data, including healthcare and cybersecurity. DP-SGD has been shown to demonstrate that deep neural networks with non-convex objectives can be trained under a modest privacy budget, at a manageable cost in software complexity and model quality. A non-convex objective is one that may have multiple local minima, making optimization more challenging than with convex objectives. Existing approaches require large privacy budgets to train and incur high overheads in computational resources. A privacy budget refers to the total amount of privacy loss allowed over the entire training process. DP-SGD follows the same steps as standard stochastic gradient descent (SGD). However, it also clips the gradients' norm to a threshold and then add Gaussian noise. Gaussian noise is a type of random noise drawn from a normal distribution. Differential privacy is formally defined using the parameters (ε, δ), which bound the privacy loss of any algorithm. DP-SGD tracks privacy loss by a method called the moments accountant. Current implementations use a method called Rényi differential privacy, which provides an even tighter privacy accounting than the original moments accountant. The moments accountant tracks the privacy loss as a random variable at each step. Another privacy-preserving training method is Private Aggregation of Teacher Ensembles (PATE), which uses an ensemble of teacher models to label public data. A teacher model is a model trained on private data that is used to label or provide guidance to another model (the student model).
DP-SGD uses a subsampling method where each mini-batch is formed by sampling each example independently with probability q. This provides privacy amplification by subsampling. Subsampling means selecting a random subset of the data for each training step rather than using the full dataset. The privacy parameters include the clipping norm (C) and the noise scale (σ). The clipping norm is the maximum allowed length of a gradient. Any gradient longer than C is scaled down to length C. The noise scale on the other hand controls how much random noise is added to the gradients. These parameters can determine the privacy-utility trade-off. The noise scale σ is calibrated such that the noise variance is proportional to C²σ². Unlike standard SGD, DP-SGD's privacy loss accumulates over multiple training steps, and the moments accountant can track this cumulative loss to determine the overall privacy guarantee, usually denoted as ε (epsilon), δ (delta). An ε controls how information about any single example can be leaked. Likewise, a δ is a small probability that the privacy guarantee fails. Hence, it provides tighter estimates on the overall privacy loss. Privacy loss is a measure of how much information an individual training example can be inferred from the algorithm's output.
Federated learning (also known as collaborative learning) is a machine learning technique in a setting where multiple entities (often called clients) collaboratively train a model while keeping their data decentralized, rather than centrally stored. A defining characteristic of federated learning is data heterogeneity. Because client data is decentralized, data samples held by each client may not be independently and identically distributed. Federated learning is generally concerned with and motivated by issues such as data privacy, data minimization, and data access rights. Its applications involve a variety of research areas including defence, telecommunications, the Internet of things, and pharmaceuticals.
f ( x 1 , … , x K ) = 1 K ∑ i = 1 K f i ( x i ) {\displaystyle f(\mathbf {x} _{1},\dots ,\mathbf {x} _{K})={\dfrac {1}{K}}\sum _{i=1}^{K}f_{i}(\mathbf {x} _{i})}
where K {\displaystyle K} is the number of nodes, x i {\displaystyle \mathbf {x} _{i}} are the weights of model as viewed by node i {\displaystyle i} , and f i {\displaystyle f_{i}} is node i {\displaystyle i} 's local objective function, which describes how model weights x i {\displaystyle \mathbf {x} _{i}} conforms to node i {\displaystyle i} 's local dataset. The goal of federated learning is to train a common model on all of the nodes' local datasets, in other words:
Optimizing the objective function f ( x 1 , … , x K ) {\displaystyle f(\mathbf {x} _{1},\dots ,\mathbf {x} _{K})} . Achieving consensus on x i {\displaystyle \mathbf {x} _{i}} . In other words, x 1 , … , x K {\displaystyle \mathbf {x} _{1},\dots ,\mathbf {x} _{K}} converge to some common x {\displaystyle \mathbf {x} } at the end of the training process.
Initialization: according to the server inputs, a machine learning model (e.g., linear regression, neural network, boosting) is chosen to be trained on local nodes and initialized. Then, nodes are activated and wait for the central server to give the calculation tasks. Client selection: a fraction of local nodes are selected to start training on local data. The selected nodes acquire the current statistical model while the others wait for the next federated round. Configuration: the central server orders selected nodes to undergo training of the model on their local data in a pre-specified fashion (e.g., for some mini-batch updates of gradient descent). Reporting: each selected node sends its local model to the server for aggregation. The central server aggregates the received models and sends back the model updates to the nodes. It also handles failures for disconnected nodes or lost model updates. The next federated round is started returning to the client selection phase. Termination: once a pre-defined termination criterion is met (e.g., a maximum number of iterations is reached or the model accuracy is greater than a threshold) the central server aggregates the updates and finalizes the global model. The procedure considered before assumes synchronized model updates. Recent federated learning developments introduced novel techniques to tackle asynchronicity during the training process, or training with dynamically varying models. Compared to synchronous approaches where local models are exchanged once the computations have been performed for all layers of the neural network, asynchronous ones leverage the properties of neural networks to exchange model updates as soon as the computations of a certain layer are available. These techniques are also commonly referred to as split learning and they can be applied both at training and inference time regardless of centralized or decentralized federated learning settings.
Covariate shift: local nodes may store examples that have different statistical distributions compared to other nodes. An example occurs in natural language processing datasets where people typically write the same digits/letters with different stroke widths or slants. Prior probability shift: local nodes may store labels that have different statistical distributions compared to other nodes. This can happen if datasets are regional and/or demographically partitioned. For example, datasets containing images of animals vary significantly from country to country. Concept drift (same label, different features): local nodes may share the same labels but some of them correspond to different features at different local nodes. For example, images that depict a particular object can vary according to the weather condition in which they were captured. Concept shift (same features, different labels): local nodes may share the same features but some of them correspond to different labels at different local nodes. For example, in natural language processing, the sentiment analysis may yield different sentiments even if the same text is observed. Unbalanced: the amount of data available at the local nodes may vary significantly in size. The loss in accuracy due to non-iid data can be bounded through using more sophisticated means of doing data normalization, rather than batch normalization.
Number of federated learning rounds: T {\displaystyle T}
Total number of nodes used in the process: K {\displaystyle K}
2. Related Work, Literature Survey & Algorithmic Foundations
Fraction of nodes used at each iteration for each node: C {\displaystyle C}
Local batch size used at each learning iteration: B {\displaystyle B}
Number of iterations for local training before pooling: N {\displaystyle N}
Those parameters have to be optimized depending on the constraints of the machine learning application (e.g., available computing power, available memory, bandwidth). For instance, stochastically choosing a limited fraction C {\displaystyle C} of nodes for each iteration diminishes computing cost and may prevent overfitting, in the same way that stochastic gradient descent can reduce overfitting.
Heterogeneity between the different local datasets: each node may have some bias with respect to the general population, and the size of the datasets may vary significantly; Temporal heterogeneity: each local dataset's distribution may vary with time; Interoperability of each node's dataset is a prerequisite; Each node's dataset may require regular curations; Hiding training data might allow attackers to inject backdoors into the global model; Lack of access to global training data makes it harder to identify unwanted biases entering the training e.g. age, gender, sexual orientation; Partial or total loss of model updates due to node failures affecting the global model; Lack of annotations or labels on the client side. Heterogeneity between processing platforms
A further governance-related issue concerns the distribution of value among participants as multi-party federated learning systems scale. As more clients contribute to training, model accuracy may approach a performance threshold, after which additional contributions yield diminishing marginal utility. This dynamic can create tensions within collaborative arrangements, as early participants may perceive later contributions as offering reduced value while still benefiting from the shared model. Such asymmetries may affect incentives to join or remain in a consortium and complicate the design of fair participation, ownership, or reward structures. Establishing transparent rules for contribution assessment and benefit allocation is therefore an important organisational challenge and represents a direction for future research.
HyFDCA is a provably convergent primal-dual algorithm for hybrid FL in at least the following settings. Hybrid Federated Setting with Complete Client Participation Horizontal Federated Setting with Random Subsets of Available Clients The authors show HyFDCA enjoys a convergence rate of O(1⁄t) which matches the convergence rate of FedAvg (see below). Vertical Federated Setting with Incomplete Client Participation The authors show HyFDCA enjoys a convergence rate of O(log(t)⁄t) whereas FedBCD exhibits a slower O(1⁄sqrt(t)) convergence rate and requires full client participation. HyFDCA provides the privacy steps that ensure privacy of client data in the primal-dual setting. These principles apply to future efforts in developing primal-dual algorithms for FL. HyFDCA empirically outperforms HyFEM and FedAvg in loss function value and validation accuracy across a multitude of problem settings and datasets (see below for more details). The authors also introduce a hyperparameter selection framework for FL with competing metrics using ideas from multiobjective optimization. There is only one other algorithm that focuses on hybrid FL, HyFEM proposed by Zhang et al. (2020). This algorithm uses a feature matching formulation that balances clients building accurate local models and the server learning an accurate global model. This requires a matching regularizer constant that must be tuned based on user goals and results in disparate local and global models. Furthermore, the convergence results provided for HyFEM only prove convergence of the matching formulation not of the original global problem. This work is substantially different from HyFDCA's approach which uses data on local clients to build a global model that converges to the same solution as if the model was trained centrally. Furthermore, the local and global models are synchronized and do not require the adjustment of a matching parameter between local and global models. However, HyFEM is suitable for a vast array of architectures including deep learning architectures, whereas HyFDCA is designed for convex problems like logistic regression and support vector machines. HyFDCA is empirically benchmarked against the aforementioned HyFEM as well as the popular FedAvg in solving convex problem (specifically classification problems) for several popular datasets (MNIST, Covtype, and News20). The authors found HyFDCA converges to a lower loss value and higher validation accuracy in less overall time in 33 of 36 comparisons examined and 36 of 36 comparisons examined with respect to the number of outer iterations. Lastly, HyFDCA only requires tuning of one hyperparameter, the number of inner iterations, as opposed to FedAvg (which requires tuning three) or HyFEM (which requires tuning four). In addition to FedAvg and HyFEM being quite difficult to optimize hyperparameters in turn greatly affecting convergence, HyFDCA's single hyperparameter allows for simpler practical implementations and hyperparameter selection methodologies.
This project is the technical implementation of the published paper Review of Data Privacy Techniques: Concepts, Scenarios and Architectures, Simulations, Challenges, and Future Directions .
Availability of supporting data : The following data support the findings of this study: The Heart Failure Clinical Records dataset available in [UCI Machine Learning Repository] at https://doi.org/10.24432/C5Z89R ,
Training Videos : You can watch a concise series of training videos that demonstrate each section of the published academic paper, with the author delivering the content. Training Program
3. Dataset Ingestion, Preprocessing & Stochastic Augmentations
Welcome to the official documentation for Review of Data Privacy Techniques: Concepts, Scenarios and Architectures, Simulations, Challenges, and Future Directions . I am Dr. Deniz Dahman, the creator of the BireyselValue algorithm and the author of this project. The following section will provide a brief introduction to the core idea of the project , along with a reference to the academic publication. I would like to inform you that this work was conducted independently, without any funding or similar support.
I am committed to continuing and seeking further enhancements to the review paper. Should you wish to contribute to this work in any manner, please refer to the details in the contributing section.
If you're interested in supporting the creator and author of this project, you might consider exploring the various available options for contribution.
If you prefer any other way of contribution , please feel free to contact me directly on contact .
This review offers a thorough introduction to the concept of privacy, focusing specifically on the application of differential privacy within machine learning . Its primary goal is to elucidate the key facets of privacy when utilizing AI frameworks, thereby facilitating researchers and students in gaining a coherent understanding from a singular resource . Additionally, the project provides lab implementations in Python for several key topics . In essence, apart from presenting available open-source tools for privacy in machine learning, the author has chosen to demonstrate the core concepts of the abstract within a hypothetical setup environment. While the review does not guarantee mastery over every discussed topic, it aims to provide a substantial comprehension, enabling the reader to further explore specific areas related to the discourse on privacy in machine learning. The project is structured into sections as outlined below.
This section focuses on three core elements: data, AI frameworks, and privacy. It seeks to establish a link between these components , leading to the main emphasis—data privacy in the context of machine learning and AI frameworks.
Exploring the diverse techniques and methods for applying data privacy across various scenarios can be aided by numerous open-source tools. However, this project adopts a unique approach. Rather than merely introducing the abstract concept and then recommending an existing tool for implementation, it constructs lab sessions using the Python programming language . In each subsession, it builds upon the core principles of the abstract concept from the ground up and then simulates the results. This method ensures that the reader gains a solid understanding of both the mathematical and procedural aspects of the topic. The lab session will utilize a single dataset mentioned in the data availability ; importantly, the nature of the dataset, including its field of origin or the types of features it contains, will not be a concern. This is because the paper intends to use the dataset solely as an illustrative example, and consequently, there will be no evaluation of outcome metrics such as accuracy, efficiency, or the like
The discussions in the previous sections (1 and 2) have underscored the significance of embedding privacy as a core element in the use of data for general analytics or predictive modeling within AI and ML frameworks. This section will present detailed, motivating examples related to data privacy issues, followed by a laboratory simulation of a data privacy breach.
As discussions around data privacy have intensified in recent years, numerous approaches have been explored to address the issue from both theoretical and practical perspectives . While these techniques may seem disparate at first glance, they are interconnected to some degree. Differential Privacy stands out as a significant mathematical concept in this domain . This section will present the latest techniques for addressing data privacy concerns . Importantly, the arrangement of these techniques is not presented as isolated topics but as a continuum of related subjects. Consequently, the ensuing subsections and simulated laboratories will be discussed in a logical sequence
Despite the promising mathematical representation of differential privacy , there are still challenges in the field today. This section discuss those challenges in details.
4. Neural Network Backbone, Layer Specifications & Loss Formulations
This project conducted an extensive survey on data privacy . It provided a wide-ranging viewpoint, linking data, AI & ML frameworks, and privacy concerns. The review outlined two scenarios where privacy is compromised and explored different initiatives to tackle data privacy issues. A notable aspect of this work was the in-depth analysis of the "Differential Privacy" framework , a leading subject in current privacy research. Challenges and future prospects regarding the Differential Privacy (DP) framework were also examined. It has become evident that incorporating a privacy parameter into data usage for any purpose is crucial. The existing methods and frameworks, particularly the differential privacy framework, appear to be quite promising. It is anticipated that this framework will continue to evolve in the coming years and may become the new benchmark for data privacy. Regardless of the advancements a framework makes, without public knowledge and understanding of privacy technicalities, which is difficult to expect from non-technical individuals, addressing privacy breaches becomes an almost unattainable goal . This is because if people remain uninformed about the technical aspects of privacy concerning their data, they have no choice but to trust the curator's assurance that their privacy is intact. While this may be true, the question arises: if the curator uses the data entrusted to them without the explicit consent of the owner for their own benefit, can it be considered a breach of privacy? Lastly, this overview serves as a foundation for the "data privacy" community interested in developing various techniques for data protection. Moreover, it enables researchers to determine the most appropriate course of action to offer more precise alternatives in the field
please follow up on the publications on the website to find the academic published paper
Review of Data Privacy Techniques: Concepts, Scenarios & Architectures, Simulations, Challenges, and Future Directions
Deep-Learning-with-Differential-Privacy Objective This project serves as an introduction to reading ML literature, and then applying this knowledge to deep learning and differential privacy concerns. The goal of this project is to understand deep learning models and how to protect the privacy of an individual’s data. Different algorithmic techniques for learning was implemented on medical image datasets and an analysis of privacy costs within the framework of differential privacy was be completed to evaluate the merits and room for improvement of different techniques. This project's deliverable was a research paper summarizing the results found throughout the fall and winter semesters. The paper can be found here . Team Members Nicole Streltsov ( @NicoleStrel ) Ritvik Jayanthi ( @RitvikJayanthi ) Alec Dong ( @AlecDong ) Ria Upreti ( @ria-upreti ) Akriti Sharma ( @Akriti-Sharma1 ) Bolade Amoussou ( @cdw18 ) Mikhael Orteza ( @xPreliator ) Divya Gupta ( @gdivyagupta ) Contents Datasets : /chest-data/ : gzip Numpy array files, from Chest Pneumonia X-ray images dataset /knee-data/ : gzip Numpy array files, from Knee Osteoarthritis X-ray images dataset Techniques : /DP-SGD/ (Tensorflow Objax): Differential Privacy with Stochiastic Gradient Descent, from the paper Abadi et al. /DP-SGD-JL/ (Tensorflow Keras): Differential Privacy with Stochastic Gradient Descent and JL Projections, from the paper Bu et al. /DP-SGD-FL/ (PyTorch): Differential Privacy with Stochastic Gradient Descent and Federated Learning, referencing the paper Wei et al. /PATE/ (PyTorch): Private Aggregation of Teacher Ensembles (PATE) algorithm, from the paper Uniyal et al. Python Scripts : load_dataset_into_pickle.py : reads a directory of images, transforms the data into Numpy arrays, applies data segmentation and saves into gzip pickle files. visualize_dataset.py : reads a directory of images to create a scatter plot of image size and label distribution. metrics_calc_helper_functions.py : helper functions to calculate metrics for comparison, and to dump the data into text files. runtime_and_memory_graphs.py : generates graphs to compare memory/runtime of all techniques for the chest and knee datasets. Metrics : /metrics/ : stores text files of the metrics from our techniques for both the chest and knee datasets
This project serves as an introduction to reading ML literature, and then applying this knowledge to deep learning and differential privacy concerns. The goal of this project is to understand deep learning models and how to protect the privacy of an individual’s data. Different algorithmic techniques for learning was implemented on medical image datasets and an analysis of privacy costs within the framework of differential privacy was be completed to evaluate the merits and room for improvement of different techniques. This project's deliverable was a research paper summarizing the results found throughout the fall and winter semesters. The paper can be found here .
University of Toronto's Trustworthy Machine Intelligence (TMI) Deep Learning with Differential Privacy Project
Deep Learning with Differential Privacy - Experiment Reproduction This project reproduces the experiments from the paper "Deep Learning with Differential Privacy" by Abadi et al. using TensorFlow Privacy. 🎯 Project Overview This implementation provides: DP-SGD Training : Using TensorFlow Privacy's DPKerasSGDOptimizer CNN Model : Reproducing the paper's CNN architecture for MNIST Privacy Analysis : Computing privacy budgets (ε, δ) for different configurations Comprehensive Evaluation : Multiple privacy settings with accuracy measurements Publication-Quality Visualizations : Privacy-accuracy trade-off plots 📁 Project Structure privacy/ ├── config.py # Experiment configurations and hyperparameters ├── data_loader.py # MNIST data loading and preprocessing ├── models.py # CNN model architecture ├── dp_training.py # Differential privacy training logic ├── run_experiments.py # Main experiment runner ├── visualization.py # Results visualization and plotting ├── requirements.txt # Python dependencies └── README.md # This file 🚀 Quick Start 1. Install Dependencies pip install -r requirements.txt 2. Run All Experiments python run_experiments.py This will run experiments with different privacy budgets: Non-private baseline Strong privacy (ε=2.0) Medium privacy (ε=4.0) Weak privacy (ε=8.0) Very weak privacy (ε=16.0) 3. Generate Visualizations python visualization.py 4. Run Single Experiment python run_experiments.py --config strong_privacy 📊 Expected Results The experiments will generate: Privacy-Accuracy Trade-off Plot : Shows how test accuracy decreases as privacy increases Training Curves : Training/validation accuracy over epochs for each privacy setting Noise Impact Analysis : Effect of noise multiplier on model performance Summary Table : Comprehensive results table with all metrics 🔧 Configuration Privacy Settings Edit config.py to modify privacy parameters: DP_CONFIGS = [ { 'name' : 'custom_privacy' , 'l2_norm_clip' : 1.0 , # Gradient clipping threshold 'noise_multiplier' : 1.2 , # Noise level 'epsilon' : 3.0 , # Target privacy budget 'delta' : 1e-5 , # Privacy parameter 'microbatches' : 250 # Number of microbatches } ] Model Architecture The CNN model follows the paper specification: Conv1: 16 filters, 8×8 kernel, stride 2, tanh activation Conv2: 32 filters, 4×4 kernel, stride 2, tanh activation Dense: 32 units, tanh activation Dropout: 0.25 Output: 10 classes, softmax activation Training Parameters Batch Size : 250 (as in paper) Epochs : 60 Learning Rate : 0.15 Momentum : 0.9 📈 Understanding Results Privacy Budget (ε, δ) Lower ε : Stronger privacy, typically lower accuracy Higher ε : Weaker privacy, typically higher accuracy δ : Probability of privacy breach (usually 1e-5) Key Metrics Test Accuracy : Final model performance on test set Privacy Spent : Actual (ε, δ) computed by TF Privacy Training Time : Time to complete training 🔬 Experiment Details Differential Privacy Implementation Uses DPKerasSGDOptimizer from TensorFlow Privacy Implements per-example gradient clipping Adds calibrated Gaussian noise to gradients Computes privacy spent using RDP analysis Privacy Accounting Uses Rényi Differential Privacy (RDP) for tight analysis Converts RDP to (ε, δ)-DP for interpretability Accounts for composition over training steps 📋 Results Interpretation Expected accuracy ranges (approximate): Non-private : ~99% test accuracy ε=16 : ~97-98% test accuracy ε=8 : ~95-97% test accuracy ε=4 : ~92-95% test accuracy ε=2 : ~85-92% test accuracy 🛠 Troubleshooting Common Issues Memory Errors : Reduce batch size in config.py Slow Training : Reduce number of epochs for testing Import Errors : Ensure TensorFlow Privacy is installed correctly Performance Tips Use GPU for faster training: pip install tensorflow-gpu Reduce dataset size for quick testing Adjust microbatch size based on available memory 📚 References Deep Learning with Differential Privacy - Abadi et al. TensorFlow Privacy - Official implementation Differential Privacy - Background 🤝 Contributing Feel free to: Add new model architectures Implement additional datasets Improve visualization plots Add more privacy analysis tools 📄 License This project is for educational and research purposes, reproducing published academic work.
This project reproduces the experiments from the paper "Deep Learning with Differential Privacy" by Abadi et al. using TensorFlow Privacy.
privacy/ ├── config.py # Experiment configurations and hyperparameters ├── data_loader.py # MNIST data loading and preprocessing ├── models.py # CNN model architecture ├── dp_training.py # Differential privacy training logic ├── run_experiments.py # Main experiment runner ├── visualization.py # Results visualization and plotting ├── requirements.txt # Python dependencies └── README.md # This file
DP_CONFIGS = [ { 'name' : 'custom_privacy' , 'l2_norm_clip' : 1.0 , # Gradient clipping threshold 'noise_multiplier' : 1.2 , # Noise level 'epsilon' : 3.0 , # Target privacy budget 'delta' : 1e-5 , # Privacy parameter 'microbatches' : 250 # Number of microbatches } ]
5. Training Protocol, Convergence Behavior & Experimental Evaluation
This project is for educational and research purposes, reproducing published academic work.
This project reproduces the experiments from the paper "Deep Learning with Differential Privacy" by Abadi et al. using TensorFlow Privacy.
weimingwill / awesome-federated-learning Star 737 All materials you need for Federated Learning: blogs, videos, papers, and softwares, etc. machine-learning privacy data-privacy distributed-optimization meta-learning federated-learning federated-optimization differential-privacy-deep-learning federated-learning-framework non-iid decentralized-federated-learning communication-efficiency statistical-heterogeneity Updated Nov 16, 2025 Shell
All materials you need for Federated Learning: blogs, videos, papers, and softwares, etc.
netsharecmu / NetShare Star 101 (SIGCOMM '22) Practical GAN-based Synthetic IP Header Trace Generation using NetShare machine-learning privacy netflow pcap time-series tensorflow generative-adversarial-network gan gans netflow-v9 differential-privacy netflow-data synthetic-data privacy-preserving synthetic-dataset-generation pcap-generator synthetic-data-generator differential-privacy-deep-learning synthetic-data-generation gans-models Updated Oct 8, 2023 Python
hharcolezi / ldp-protocols-mobility-cdrs Star 29 Implementation of local differential privacy mechanisms in Python language. machine-learning privacy ldp data-privacy differential-privacy privacy-preserving-machine-learning differential-privacy-deep-learning local-differential-privacy Updated Jul 26, 2022 Jupyter Notebook
amzn / differential-privacy-bayesian-optimization Star 28 This repo contains the underlying code for all the experiments from the paper: "Automatic Discovery of Privacy-Utility Pareto Fronts" hyperparameter-optimization bayesian-optimization pareto-front hyperparameter-tuning active-learning multiobjective-optimization differential-privacy differential-privacy-deep-learning Updated Oct 3, 2022 Python
This repo contains the underlying code for all the experiments from the paper: "Automatic Discovery of Privacy-Utility Pareto Fronts"
nikosgalanis / data-poisoning-defense-fl Star 24 💉🔐 Novel algorithm for defending against Data Poisoning Attacks in a Federated Learning scenario differential-privacy adversarial-machine-learning federated-learning differential-privacy-deep-learning data-poisoning-attacks Updated Apr 22, 2024 Jupyter Notebook
💉🔐 Novel algorithm for defending against Data Poisoning Attacks in a Federated Learning scenario
Model Figures & Evaluation Curves (4 Images)
Deep Learning Execution Pipeline
(Preprocessing)
(Feature Extraction)
(Self-Attention)
(Loss Optimization)