PUTWorkbench: Analysing Privacy in AI-intensive Systems

TL;DR

PUTWorkbench is an open-source tool designed to help practitioners balance privacy and utility in AI systems, demonstrating effective privacy-utility trade-offs with accessible models on real datasets.

Contribution

It introduces a user-friendly, open-source prototype for analyzing privacy-utility trade-offs in AI systems without requiring advanced data science knowledge.

Findings

Significant privacy-utility trade-offs achieved on real datasets

Tool is easy to extend and use by practitioners

Effective privacy models without complex data science background

Abstract

AI intensive systems that operate upon user data face the challenge of balancing data utility with privacy concerns. We propose the idea and present the prototype of an open-source tool called Privacy Utility Trade-off (PUT) Workbench which seeks to aid software practitioners to take such crucial decisions. We pick a simple privacy model that doesn't require any background knowledge in Data Science and show how even that can achieve significant results over standard and real-life datasets. The tool and the source code is made freely available for extensions and usage.

Tables

Table 1. Table 1. Results for the credit-card for (put number = 1)

Attribute Set - U
Accuracy	99.88017	Time taken	1.09846
TP_1	0.52000	TP_0	0.99964
FP_1	0.00035	FP_0	0.48000
FN_1	0.48000	FN_0	0.00035
Precision_1	0.72222	Precision_0	0.99915
Recall_1	0.52000	Recall_0	0.99964
aROC_1	0.77595	aROC_0	0.77595
aPR_1	0.46787	aPR_0	0.99915

Table 2. Table 2. Results for credit-card for (put number = 0)

	Attribute Set
	{1, 2, 5, 8, 10, 11, 14, 15, 16, 17, 21, 25, 26, 28, 29}	{1, 4, 5, 7, 10, 11, 13, 14, 15, 16, 17, 21, 25, 29, 30}	{1, 2, 4, 5, 6, 7, 14, 17, 18, 19, 22, 27, 28, 29, 30}	{3, 4, 5, 6, 7, 8, 10, 14, 16, 17, 19, 26, 27, 28, 30}	{2, 5, 6, 10, 13, 14, 15, 16, 17, 19, 21, 22, 25, 26, 30}
Accuracy	99.95841	99.95136	99.95136	99.95523	99.95206
aROC_1	0.89360	0.87870	0.87207	0.88925	0.88382
aPR_1	0.76068	0.75866	0.75325	0.75057	0.75031

Table 3. Table 3. Results for credit-card for (put number = -1)

	Attribute Set
	{1}	{2}	{3}	{4}	{5}
Accuracy	99.83083	99.82378	99.90131	99.85197	99.79558
aROC_1	0.48328	0.49995	0.47138	0.48092	0.48616
aPR_1	0.00162	0.00176	0.00092	0.00142	0.00197
	Attribute Set
	{6}	{7}	{8}	{9}	{10}
Accuracy	99.82378	99.86607	99.83083	99.85902	99.85197
aROC_1	0.49995	0.47890	0.48328	0.65941	0.79118
aPR_1	0.00176	0.00127	0.00162	0.06737	0.32891
	Attribute Set
	{11}	{12}	{13}	{14}	{15}
Accuracy	99.90836	99.92246	99.85197	99.92246	99.88017
aROC_1	0.75380	0.73174	0.48092	0.92222	0.46470
aPR_1	0.48456	0.41327	0.00142	0.57707	0.00112
	Attribute Set
	{16}	{17}	{18}	{19}	{20}
Accuracy	99.86607	99.85902	99.90131	99.83787	99.83787
aROC_1	0.75253	0.80987	0.64286	0.47388	0.47388
aPR_1	0.52713	0.44304	0.36259	0.00153	0.00153
	Attribute Set
	{21}	{22}	{23}	{24}	{25}
Accuracy	99.86607	99.83787	99.86607	99.83787	99.83083
aROC_1	0.47890	0.47388	0.47890	0.47388	0.48328
aPR_1	0.00127	0.00153	0.00127	0.00153	0.00162
	Attribute Set
	{26}	{27}	{28}	{29}	{30}
Accuracy	99.78853	99.85197	99.78149	99.78149	99.84492
aROC_1	0.49995	0.48092	0.48706	0.48706	0.47272
aPR_1	0.00211	0.00142	0.00213	0.00213	0.00147

Table 4. Table 4. Results for credit-card for (0 < put number < 1)

(put number = 0.75)
	Attribute Set
	U - {1, 3, 9, 13}	U - {1, 2, 27, 28}	U - {1, 4, 20, 23}	U - {1, 2, 11, 27}	U - {1, 2, 11, 28}
Accuracy	99.94607	99.94924	99.94431	99.94536	99.94572
aROC_1	0.87628	0.86957	0.85941	0.86722	0.87862
aPR_1	0.72319	0.72218	0.71789	0.71620	0.70504

Table 5. Table 5. Results for credit-card for (-1 < put number < 0)

(put number = -0.25)
	Attribute Set
	{3, 7, 9, 10, 13, 14, 16, 17, 20, 21, 23}	{3, 4, 5, 10, 14, 15, 16, 17, 18, 23, 30}	{3, 4, 10, 14, 16, 17, 19, 23, 27, 29, 30}	{1, 4, 10, 14, 15, 16, 17, 19, 21, 24, 27}	{4, 5, 7, 9, 10, 14, 17, 21, 23, 25, 30}
Accuracy	99.95206	99.94889	99.95453	99.95136	99.94713
aROC_1	0.89486	0.88855	0.86523	0.90252	0.88281
aPR_1	0.75701	0.75214	0.75201	0.75118	0.75087

Full text

Privacy Engineering, Artificial Intelligence, Software Engineering

††copyright: none††article: 4††price: 15.00

1. Introduction

The recent advancements in Machine Learning techniques has brought AI experts and Software Practitioners on the same page. There is however a dearth of tools specially designed for building AI intensive systems. Such tools would be conceptually different from the conventional IDEs since they’ll primarily focus on models, instead of programs or modules. Also, a greater amount of time would be spent on fine-tuning existing models and finding the right parameters to a learning algorithm, instead of building exhaustive test suites to test handwritten code. Another important difference would be that instead of using a binary logic in evaluation of the models (e.g. a test case that either passes or fails), we’ll need to have mechanisms to deal with probabilities (e.g. a Classification Accuracy of 89.2%). This provides enough motivation to come up with novel ideas about newer tools, dealing with problems that arise in systems dealing with these paradigms.

1.1. Privacy-Utility Trade-off

The starting point of any Machine Learning activity includes collecting or acquiring a significant quantity of data, the more, the merrier. More often than not, this data belongs to individuals who are protected by legal guidelines such as EU’s GDPR(Regulation, 2016), putting additional tasks on software providers to ensure that they do not violate their privacy. The utility of a learning algorithm depends on its ability to “find correlations” among the provided attributes. However, not all correlations may be desirable, as they may lead to revealing the identity of individuals who were assured that their data would be sanitised via anonymisation before use. An example of how this can be done from medical records, in conjunction with a voter list, is shown in (Samarati, 2001). In any case, anonymising the data, or any other similar activity performed to achieve higher levels of privacy, usually involve “breaking correlations” that can lead to user identification. The exact correlations that need to be preserved or broken depend on the actual use-case. In essence, any Machine Learning activity, when applied in a real-world software system, needs to achieve a trade-off between privacy and utility. A tool that allows a software practitioner to evaluate custom privacy scenarios against their datasets can help achieve a near optimal solution on this virtual trade-off scale.

1.2. Envisioned Users

The users who we envision to pay attention to such a tool are software practitioners who are working on a new AI-intensive system or those who are tasked with ensuring that a similar existing system meet certain privacy guidelines. For instance, the GDPR(Regulation, 2016) compliance date of May 25, 2018 forced many providers to send revised privacy notices to their users as they’ll be liable for legal action if they do not meet the regulation’s requirements beyond the deadline. We can expect that in future, more similar guidelines will be put in place, with which the software providers will need to abide. One particular challenge that hampers adoption of sophisticated privacy techniques is that more often than not, it’ll require an expert in the field of Data Science to understand the nuances of complex correlations and befuddling statistical metrices. A typical software practitioner need not necessarily have the expected skill-set to deal with this scenario. Our primary goal is to build a tool that doesn’t require upfront knowledge of these concepts. The initial version uses a model that doesn’t involve any extra metrices than what the practitioner may have already seen.

2. The Simple Privacy Model

To build the initial version of the tool, we’ve used a model that is relatively simple and intuitive. The model is based on the Privacy as the Default Setting principle(Cavoukian, 2009), specifically, relating to the FIPs Collection limitation and Data minimization(Cavoukian, 2009). In simple terms, if we don’t keep something with us, we need not worry about it being stolen or exposed.

Take the example of a system that recommends products for a user on an e-commerce website. Assume that the website stores many attributes relating to its users. For instance, the time they last visited the site, the number of products they clicked on, the number of times they pressed the “Back” button, etc. This dataset is then used by a Recommender component to show users with relevant products. Let us say the utility of the Recommender is measured in its prediction accuracy, i.e. the average percentage of instances where the user clicked on the recommended product.

Assume that the dataset contained n attributes, and m rows. Assume that the Recommender achieved an accuracy of $x\%$ with this dataset. Now consider a case when we randomly remove half of the attributes (and may be some of the rows too) from the dataset, i.e. we come up with a dataset that is a partition of the original dataset. Assume that we fed this dataset to the same Recommender, and it achieved an accuracy of $y\%$. Let us concentrate on the pessimistic case where this reduction in the size of the dataset hampered the utility of the Recommender, i.e. $y<x$. What if the difference $(y-x)$ is not substantial? What if we are “ok” to lay off some percentage of utility, in exchange for a scenario where we store much less user information than we already do?

The Simple Privacy Model is based on this trade-off phenomenon. Based on a particular use-case, a team of Practitioners might actually choose a point where the achieved utility balances out the achieved privacy from the business perspective. Clearly, this model is simple enough to understand, without looking up a Statistics cheat-sheet. We choose this model to implement the first iteration of our tool since it is easy to understand.

2.1. Core Parameters

The model has the following core parameters:

Partition Size:- The number of attributes to pick out of the original dataset. If there are $n$ attributes111Whenever we say attributes, we exclude the “class” attribute, unless explicitly specified in the dataset, partition size is an integer between $1$ and $n$, both inclusive. Another way to provide this number is on a relative floating scale between $-1.0$ and $1.0$, where $-1.0$ corresponds to a partition size of $1$, and $1.0$ corresponds to a partition size of $n$. On this scale, [math] means $ceil(n/2)$. This scale is called PUTNumber scale, where PUTNumber stands for “Privacy Utility Trade-off Number” which maps to a unique Partition Size.

Learning Objective:- The purpose for which the dataset will be used. For the initial versions of the tool, we’ve included a small set of Classification techniques(Kotsiantis et al., 2007) as Learning Objectives.

Privacy Exceptions:- A known set of attribute sets which when put together, pose a higher risk to privacy (because they can induce undesirable correlations). Any partition that has a privacy exception, will not be considered by the tool.

Utility Exceptions:- A knows set of attribute sets which when put together, provide higher levels of utility (because they can induce desirable correlations). Any partition that has a utility exception, may be considered at higher priority by the tool, in cases where it cannot consider all possible combinations.

The Partition Size and Learning Objectives are required parameters, while the exceptions are optional. It may be noted that for partitions which contain at least one privacy exception as well as one or more utility exceptions, privacy exceptions take precedence (i.e. such a partition is not considered by the tool). In essence, while privacy exceptions are “bindings”, utility exceptions are mere “suggestions”, which may or may not be accepted by the tool.

2.2. Tool-Specific Parameters

The possible number of partitions of size $k$, for a dataset with $n$ attributes is nCk. Even for moderately high values of $n$ and $k$, the number may easily be in millions. Also, number of rows in a dataset can range from $1$ to any arbitrarily large number. To make the tool computationally practical, we added some additional parameters:

Vertical Expense:- A floating point number between [math] and $1.0$, instructing what proportion of the overall possible partitions shall the tool consider. A Vertical Expense of $0.25$ means, “try only 25% of all possible combinations”.

Horizontal Expense:- A floating point number between [math] and $1.0$, instructing what proportion of the overall rows shall be part of any given partition. A Horizontal Expense of $0.10$ means, “put only 10% of total rows in any partition”.

Generation Method:- Suggests a way to generate the Attribute-sets. Random Generation method generates sets in a random fashion. Dictionary Generation method generates them systematically in a dictionary order222Dictionary order looks like this -¿ {1,2,3}, {1,2,4} … {1,2,n}, {2,3,4}, {2,3,5} ….

There are some other lesser important parameters too in the tool which are meant for fine-tuning that we omit here. The default value for the two expenses is $1.0$. By default, the generation takes place in Dictionary Order.

3. Methodology

Figure 1 shows a pictorial overview of the tool. The overall methodology can be summarized as:

1. (1)

Runs a set of validity checks over the supplied parameters. For instance, it checks that the dataset has a “nominal” (and not “numeric”) class attribute. 2. (2)

Applies any filtering options over the dataset, if requested. For instance, removal of rows with missing values, or filling them with mean or mode. 3. (3)

Decides upon the Attribute-set Generation Method. If the partitions to generate are fairly high, using the Random Method is generally a better option. The default method is Dictionary Method. The actual number of partitions to generate roughly equals “$v$ times nCk”, where $v$ is the Vertical Expense, $n$ is the total number of attributes in the dataset, and $k$ is the Partition Size. 4. (4)

Any Partitions containing a Privacy Exception are not considered by the tool any further. If $v$ was less than $1.0$, and some Partitions needed to be ignored, the one having Utility Exceptions are sparred the axe, to whatever extent possible. 5. (5)

For each Attribute-set, a Partition of the dataset is created by including some or all rows from the original dataset, keeping only those attributes, which are in the said Attribute-set. The number of rows included in any partition roughly equals “$h$ times $m$”, where $m$ is the total number of rows in the dataset. These rows are randomly selected from the original dataset. 6. (6)

For each Partition, a Classification task is forked, using the requested technique. All the metrics produced by the task, such as Accuracy, False Positive Rate, Area under ROC Curve etc. are recorded. 7. (7)

A Result file is prepared keeping all the above collected statistics. In the GUI version of the tool, a tab for analysing these results is shown, with multiple filtering options.

At the core, the aim is to suggest the user with a subset of the attributes in the original dataset, which can provide significant utility for the selected Classification activity.

4. Tool

The tool comes in two forms, one with a Command-Line Interface (CLI) and another with a GUI. The tool’s package also contains two auxiliary helper tools. The tool is built using maven(mav, [n. d.]) and is available as a public repository(Srivastava, 2018a) under the MIT license(Initiative et al., 2006). The Downloads section of the repository provides zipped versions for Windows and Linux platforms, along with a packaged, JAR version. There is also a short User Manual accessible on the same page. An introductory video of the tool is available on YouTube(Srivastava, 2018b).

4.1. GUI Version

The UI version provides basic filtering and analysis facilities inline after the experiment completes. Figure 2 gives a glimpse of the Analysis Tab of the UI tool. One can sort results according to a metric of choice, in increasing or decreasing order. Also, if one needs to see how well or poorly a set of attributes performed, that too can be achieved using the filtering options. For the first time users, the GUI tool has an “experimental” feature called the Autopilot. After loading a dataset, the Autopilot can be engaged to find common values of the required input parameters for the dataset. The Autopilot can be disengaged at any point in time if the user feels like taking control of the settings.

4.2. CLI Version

The CLI version can be handy if one needs to try out a spectrum of different partition sizes together. The CLI tool has switches to provide details of the dataset, Classifier, Partition Size, Exceptions, Expenses and several other settings. The advantage of the CLI tool is that it can be invoked with different input values using a script and be left to complete in the background (say over a weekend). This could be particularly helpful for practitioners, as they can let the data be collected over time, while they tend to other tasks.

4.3. Auxiliary Tools

The tool’s package has two auxiliary CLI tools called the Verifier tool and the Recovery Tool at the user’s disposal.

The Verifier tool can be used for validating results produced by the main tool. For instance, in cases where the dataset is too big to conduct multiple Classification tasks practically, one may choose to keep the Horizontal Expense to a fairly low value. This, however, would reduce the confidence in the results, since they may have overfitted a small portion of the large dataset. The Verifier tool can be invoked to try a (sub)set of Attribute Sets reported to be providing encouraging results, over the complete dataset, and observe the difference in the produced metrices between the two cases.

The Recovery tool is an SoS application that can be invoked to “resume” an abruptly stopped experiment due to mistakes (say by pressing “Ctrl + C”) or problems (say power or network failures). When an experiment running for several hours or days gets killed, the Recovery tool can either dump the results already collected, or resume the experiment from the last saved state.

5. Experimental Results

In order to evaluate our model, and test the tool over a real world dataset, we conducted three sets of experiments over varying dataset sizes. For some experiments, we used two classification techniques as the learning mechanism - Naive Bayes and J48 Decision Trees. For larger experiments, we choose only J48 due to computational constraints. We now present the results of our experiments. The first two datasets are standard datasets popularly used for reporting results by researchers in the privacy domain. The third dataset is a real world credit card fraud dataset, with additional challenges. The tool was set throughout to use 5-fold cross-validation for producing any result.

5.1. Truncated Adult dataset

The first objective of our experiments was to test if the hypothesis can even be applied to a real world dataset. We needed a small dataset to start with in order to quickly verify our model. To do this we chose a subset of UCI Adult Dataset, which was originally used by Iyengar(Iyengar, 2002). Over the years, the setup was replicated by many researchers ((Bayardo and Agrawal, 2005)(LeFevre et al., 2006)(LeFevre et al., 2005) etc.), and has become a de facto dataset to report results for researchers working in the privacy domain. We refer to this dataset as adult-iyengar. The dataset contained only 8 attributes (and the class attribute) from the original dataset. We skip the exact details of how the dataset was produced from the original dataset as they are exactly the same as described by Iyengar.

Figure 3 shows the results of the experiments. We intended to see how the classification accuracy was affected, on selecting a smaller subset of the dataset. For this, we varied the partition size from 1 to n (in this case, n = 8) and invoked the tool in order to find a partition, that provides accuracy within reasonable range of the reference accuracy value (accuracy achieved when the entire dataset is presented). It can be seen that the accuracy remains within reasonable limits for partition sizes of 3 or more. This means that choosing a smaller subset of attributes does not affect utility to a great extent, while providing a higher level of privacy.

5.2. Complete Adult dataset

The adult-iyengar dataset can be considered a small, representative dataset, but it is certainly not exhaustive. Our next set of experiments used the complete UCI Adult dataset(Lichman, 2013). First, we ran the same profile of experiments as we did before, i.e. we varied the values of partition size, and plotted the highest accuracy achieved for each partition size. During this phase, we kept the vertical and horizontal expense parameters at their full values, and asked the tool to use dictionary order generation instead of random generation for these experiments333The same profile applied to the experiments in Section 5.1 as well.. We refer to this dataset as adult-complete. The dataset contained all the 14 attributes (and the class attribute) of the original dataset. We removed any duplicate or conflicting instances, as well as those with missing values to obtain a clean dataset with 45,175 rows. The results of this set of experiments are shown in Figure 4.

As seen, the trend observed for the experiments in Section 5.1 is reproduced on a larger dataset. Beyond a certain partition size, the accuracy achieved is within a fair range of that being achieved with the use of all attributes. This provides more confidence that such a model can be used in a real world scenario.

We then performed two other sets of experiments as well on the adult-complete dataset. The experiments aimed at seeing the impact of considering only a smaller set of attributes and/or instances on the results of the tool. This is important because if the results degrade significantly on application of our engineering parameters, i.e. vertical and horizontal expense, then the tool cannot be considered practical enough to be used in a real world setting. The results are shown in Figure 5.

We changed the values of v and h to see if the trend is changed. Figure 5(a) and 5(c) show the impact of varying the values of h, essentially meaning inclusion of lesser number of rows per partition. It can be seen that for both the classifiers, varying value of h, still keeps the accuracy within reasonable limits of the corresponding case, where all the rows were included in the partition. This shows that reducing the size of the partitions did not have significant impact on the model. This is reassuring because for large datasets, keeping a relatively low value of h could be a necessity, but doing so should not impact the overall results by much.

Lastly, we compared the accuracy readings reported by the tool for different values of v, essentially meaning that certain partitions were never tried by the tool, before reporting the highest accuracy for that partition number. Figure 5(b) and 5(d) show the results of the experiments. One thing to point out here is that reducing v for partition size equal to n (14 in this case) is not applicable, since there is only one partition to try in such cases. Clearly, the reduction of vertical expense parameter did have some impact on the highest accuracy, but the tool was still able to find a partition that could provide accuracy within a reasonable range of the corresponding experiment where all partitions were tried.

This provides confidence in cases where the total number of partitions that can be formulated are too many. Trying out the learning objective even over a small set of systematically chosen partitions, can still provide a solution within practical limits for use.

5.3. Credit Card Fraud dataset

In order to evaluate the model and the tool we built over a real world dataset, we chose a credit card fraud dataset(ccf, [n. d.]). The dataset contains anatomized credit card transactions by some European cardholders in September 2013. We refer to this dataset as the credit-card dataset. The dataset has already been sanitized into 28 attributes (numbered V1 to V28) along with two more attributes, Amount and Time, making a total of 30 attributes (plus the class attribute which has binary values with 1 indicating a fraudulent transaction and 0 indicating otherwise). The dataset is highly unbalanced(Dal Pozzolo et al., 2015), which is typical for a credit card fraud use-case. Out of a total of 284,807 transactions, only 492 are tagged as frauds. This places an additional challenge since classification accuracy may no longer be a good metric for the model to use. We therefore, looked at other metrics that the tool generates in order to analyse the privacy concerns.

We now elaborate some of the used conventions:

• •

The tool numbered the attributes serially, in the order they are present in the input (ARFF(arf, [n. d.])) data file.

• •

The tool produced a CSV file as output, containing the following fields for every classification task taken up in the experiment. The values of i were 0 (the class of valid transactions) and 1 (the class of fraudulent transactions).

[TABLE]

• •

The Time and Amount attributes are the first and last attributes in the dataset, being referred to as Attribute# 1 and Attribute# 30 respectively. The attributes V1 to V28 are referred to as Attribute# 2 to Attribute# 29 respectively.

• •

Since we are more interested in the ability of the classification task to be able to predict a fraudulent transaction, throughout, we focus on the metrics collected for class 1 more than that for class 0.

• •

Although the tool reports all the above metrics in the output file, for the discussion, we focus on the area under PR curve, area under ROC curve and the Accuracy as the main metrics for analysis. In particular, for credit card fraud datasets, which are often highly imbalanced in nature, using area under PR curve could be a better option than area under ROC curve or Accuracy(cre, [n. d.]). Therefore, for discussions, we sort our results in non-decreasing order, with aPR_1, aROC_1 and Accuracy being the primary, secondary and tertiary criterion respectively.

Based on the trade-off model, we treat two cases as our reference cases. The case where all attributes in the dataset are used, is the case where we provide least weightage to privacy, and highest weightage to utility. The exact opposite, is the case where we use only one attribute from the dataset at a time and try to perform the learning (in this case, perform a “classification” task using the “J48” decision tree algorithm). We present the findings of these two cases first to give an idea of the two extremes.

The data produced by the tool when invoked with put number = -1 (partition size = 1) is shown in Table 3. The tool produced values for all fields shown in Table 1, but as mentioned before, we have shown only a fraction of overall data, that is relevant. Clearly, the Accuracy is very high in all cases. This can be attributed to the fact that since the fraudulent transactions are fairly low in number, even a dumb predictor which predicts the same class all the time (class 0), can still end up with very high Accuracy.

For all other cases, where the number of partitions tried were fairly high in number, we followed the following procedure, to narrow down to a small set of useful partitions, for a given put number:

1. (1)

We first ran a longer, initial experiment, for the given put number, with small values of vertical and horizontal expenses (v and h) to avoid high computational costs. 2. (2)

We then sorted the collected results using sort criteria mentioned before. In order to validate these results over the complete dataset, we chose a small set (in the order of 20 to 100) of partitions which performed well in the initial experiment, and ran our Verifier CLI tool (4.3) over these set of partitions, to collect statistics over the complete dataset. This alleviated our concerns of overfitting. 3. (3)

We sorted the collected results again using the sort criteria mentioned before. We then chose the top five partitions that performed the best for the given put number.

The case which falls in the middle of our privacy model, is where put number is chosen as 0. In this case, it mapped to a partition size of 15 (out of 30). The top five results, obtained via the selection procedure mentioned before are shown in Table 2. We must add that we were able to come up with these sets of partitions, despite the fact that we had to use fairly low values of v and h, in order to keep the number of partitions to be tried, to a manageable number. This provides a good confidence for using the tool, for cases where computational resources are limited.

The cases where utility were given higher precedence over privacy were the ones where the put number was set to a value “relatively” closer to 1 as compared to -1. For our experiments, we chose 3 values for usage: 0.75, 0.5 and 0.25. They mapped to partition size of 26, 22 and 19 respectively. Selected results for these values are shown in Table 4. As discussed before, due to lack of space, we are presenting only selected metrics, that too for the top five partitions only. For theses cases, we use a compact representation of a partition, where we show the indices of the attributes that should be removed from the original set containing all the attributes (U), instead of listing the attributes forming the partition.

It can be seen that the partitions for these cases actually perform even better than the case when we used the whole dataset. This behaviour is typical for many feature selection activities, where dropping least relevant features (which are essentially noise for the learning process) can actually increase the efficiency of the learning component.

The cases where privacy were given more importance than utility, are the ones where we kept the put number below 0. The values we chose were: -0.25, -0.5 and -0.75. They mapped to partition size of 11, 8 and 4 respectively.

The top five results obtained via the selection procedure mentioned before are shown in Table 5. It can be seen that even dropping to a value as low as -0.75 still provides us with some partitions having decent values for the aPR_1 metric. For other two cases, the values for the aPR_1 metric is actually as good as cases with higher precedence to utility. This is a reminder to the fact that even a privacy model which is simply based on the Collection limitation and Data minimization practices(Cavoukian, 2009), can still be applicable to real world scenarios.

6. Related Work

We provide a brief overview of some of the work, that is relevant to our own work in this section. We divide the work of our interest into three categories (not necessarily exclusive).

First, there has been significant amount of work which can be summed up as “attempts to build differentially private(Dwork, 2006) versions of certain machine learning techniques”. For instance, researchers have worked on building differentially private versions of SVM(Rubinstein et al., 2009), linear and logistic regression(Zhang et al., 2012), bayesian detection(Li and Oechtering, 2015), random forests(Fletcher and Islam, 2017), nearest neighbor classification(Gursoy et al., 2017) and even the relatively recent deep learning methods(Abadi et al., 2016). Attempts to articulate generic methods for doing so like “input perturbation” or “output perturbation” have also been made(Sarwate and Chaudhuri, 2013). From a practitioner’s view, these works can only be of importance if they are converted into (possibly free and open-source) software components, which can be integrated with either an existing application, or be used as a “black-box”. Unfortunately, majority of them are restricted to demo applications only, and not as stable software components to be used in production. There are some appreciable initiatives towards bridging this gap (Mohan et al., 2012)(McSherry, 2009)(Roy et al., 2010)(Katla, 2017), but more of such efforts are required for software providers to easily integrate privacy solutions in the routine development cycle.

Second, substantial research has gone in achieving differential privacy(Dwork, 2006) in a practical setting by using the general concept of anonymisation. The most popular examples are the usage of techniques like “generalisation” and “suppression” to achieve the notion of k-anonymity(Samarati and Sweeney, 1998). Although refinements of k-anonymity, such as l-diversity (Machanavajjhala et al., 2007) and t-closeness(Li et al., 2007) have also been developed, it can be reasonable to say that k-anonymity still remains a popular choice of researchers, with multiple versions of the same (datafly(Sweeney, 1998), mondrian(LeFevre et al., 2006), incognito(LeFevre et al., 2005) etc.) available for practical usage under the UTD Anonymization Toolbox(utd, [n. d.]). However, a practical limitation of k-anonymity that we observed while trying to use the toolbox is that implementing generalisation involves a non trivial task of defining a “taxonomy tree” for nominal attributes, so that the algorithm can move up in the tree to replace specific values (say for an attribute called workclass) like “Local Government”, “Federal Government” or “State Government” to a more general value “Government”. 444This particular example is quoted from the work by Iyengar (Iyengar, 2002). If two researchers select two different ways to generalise values, we may end up with two different, incomparable versions of the same dataset, both implementing the same version of k-anonymity with same value of k. From a practitioner’s view, providing these taxonomies manually will involve the arduous process of agreement among the stakeholders.

Third, there are relatively recent works, which are precursor to our work, that propose the idea of privacy-aware feature selection (Pattuk et al., 2015)(Pattuk et al., 2016)(Aristodimou et al., 2016)(Yang and Li, 2014)(Thakurta and Smith, 2013)(Sheikhalishahi and Martinelli, 2017). Our work contrasts these works in either one or both of the following ways. First, our model doesn’t expect any prerequisites from the user in the fields of Probability, Statistics, Information Theory etc. We do so by explaining the nuances of the model using metrics that a practitioner may already be accustomed to (such as “Classification Accuracy”), instead of defining a new privacy metric that needs background reading. Second, we chose to provide an engineering solution to the problem, by providing a hands-on tool to analyze our model over any dataset, with no or minimal pre-processing555Our tool provides one-click options to handle missing values or duplicate instances in the input dataset, providing a safety net for algorithms that can’t work with them.. This too is important, because we intend to provide a solution for a community which might be tempted towards using a GUI based tool for analysing their dataset for impacts of privacy preservation. To the best of our knowledge, our work is the first to address these issues.

7. Conclusion and Future Work

In this work, we presented the idea, prototype and initial results related to a tool intended to aid software practitioners in making crucial decisions about usage of user data in their applications. In order to do so, we picked a fairly simple privacy model, which can be appreciated without any background knowledge in Data Science.

We showed an evaluation of our model via the use of our tool with experiments designed over the UCI Adult Dataset, a de-facto benchmark for researchers in the field. We also showed how the tool can be used in a real world scenario, by running various experiments over a credit card fraud dataset containing actual transaction data of some European cardholders.

The usual way of using this tool should be starting with a fairly low value of put number (or partition size) and evaluate the collected metrics for the given choice. If the results are within “acceptable” range of utility (e.g. Accuracy in excess of 85% or area under PR Curve in excess of 0.75), a suitable partition (or set of partitions) shall be tried out in real world, and be used for production. Otherwise, another experiment, with slightly higher value of put number should be tried, and so on.

In future versions, we expect to make it more generic, by including features such as support for Regression and Clustering techniques as well. We plan to add support for choosing from a wide range of learning objectives, as well as provide a mechanism to link the tool to any learning component in general, via a standardized call-and-return interface.