[Paper Review] Decision Tree Classification on Outsourced Data

Koray Mancuhan, Chris Clifton|arXiv (Cornell University)|Oct 18, 2016

Privacy-Preserving Technologies in Data18 references3 citations

TL;DR

This paper proposes a collaborative decision tree learning method (cdtl) for outsourced data under an l-diversity anatomization model, where the cloud server performs most training while the client applies lightweight refinements to improve accuracy. The approach achieves near-non-private decision tree accuracy with substantial reductions in client-side computation and memory usage.

ABSTRACT

This paper proposes a client-server decision tree learning method for outsourced private data. The privacy model is anatomization/fragmentation: the server sees data values, but the link between sensitive and identifying information is encrypted with a key known only to clients. Clients have limited processing and storage capability. Both sensitive and identifying information thus are stored on the server. The approach presented also retains most processing at the server, and client-side processing is amortized over predictions made by the clients. Experiments on various datasets show that the method produces decision trees approaching the accuracy of a non-private decision tree, while substantially reducing the client's computing resource requirements.

Motivation & Objective

• To enable accurate decision tree learning on outsourced, l-diverse data where sensitive and identifying attributes are fragmented and encrypted.
• To minimize client-side computational and storage overhead in a cloud-based data outsourcing model.
• To evaluate whether collaborative learning between client and cloud server can produce decision trees nearly as accurate as non-private models.
• To assess the trade-off between client resource savings and model accuracy in a privacy-preserving setting.

Proposed method

• The data is split into two tables: an identifier table (quasi-identifiers) and a sensitive attribute table, with join keys encrypted to prevent linkage.
• The cloud database server (CDBS) learns a base decision tree (BDT) on the fragmented data using the anonymized, l-diverse dataset.
• The client receives the BDT's largest leaf as a starting point and refines it on-the-fly using local data, minimizing client computation.
• Client-side refinement involves retraining sub-trees from the BDT’s largest leaf, with pruning applied to avoid overfitting.
• Execution time and memory savings are measured via ratios: ets = cdtl_time / cnl_time and ms = cdtl_memory / cnl_memory, where cnl is the non-private baseline.
• Experiments use 10-fold cross-validation with consistent pruning sets to fairly compare cdtl, cdbsl (cloud-only), and cnl (non-private) models.

Experimental results

Research questions

• RQ1 Can a decision tree be learned accurately on outsourced, l-diverse data using a collaborative client-server model?
• RQ2 To what extent can client-side computation and memory usage be reduced while maintaining high prediction accuracy?
• RQ3 How does the accuracy of the collaborative model (cdtl) compare to non-private and cloud-only models across diverse datasets?
• RQ4 What is the trade-off between client resource savings and model complexity, particularly in terms of overfitting?

Key findings

• The cdtl model achieves prediction accuracy that is consistently close to the non-private baseline (cnl), with average accuracy within 2-5% across datasets.
• Execution time savings (ets) and memory savings (ms) are maximized when the base decision tree (BDT) on the CDBS is complex, indicating high client-side efficiency.
• The cdbsl model, which uses only the cloud’s base tree, shows the worst accuracy, confirming that client-side refinement is essential for performance.
• Overfitting occurs in cdtl when the BDT leaf size is too small (high memory savings), particularly in the Adult dataset, where accuracy drops due to model complexity.
• The method reduces client-side learning and inference costs significantly, with memory and time savings ratios (ets and ms) approaching zero in favorable cases.
• A memory savings threshold for BDT leaf size is suggested as a mitigation for overfitting, though an optimal value is dataset-dependent and hard to define universally.