Heuristic Search for Optimal Node in Generalization Lattice
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current k-Anonymity algorithms for data anonymization are inefficient due to their NP-hard nature, requiring extensive computational resources and time, especially in large datasets, as they perform a breadth-first search through the solution space, leading to slow convergence and high resource utilization in distributed systems.
Innovation Solution
Implementing heuristic search methods that utilize a cloud computing platform to evaluate a generalization lattice, pruning non-optimal paths and using approximations for equivalence class size and suppression calculations, allowing for parallel processing without excessive data transfer, thereby reducing computational overhead and improving efficiency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a bottom-up anonymization algorithm performs a breadth first search through the solution space, then it can find a k-anonymity solution, but it takes a long time and requires extensive computational resources
Solution Approach 1:
The patent pre-computes lower bound values for all nodes in the generalization lattice before the actual search begins. This preliminary action allows the algorithm to quickly prune non-optimal paths during the breadth-first search, significantly reducing the time required to find a k-anonymity solution without sacrificing correctness
Solution Approach 2:
The patent divides the generalization lattice into levels and processes nodes level by level. By segmenting the search space and using pre-computed lower bounds to prune entire subtrees that cannot contain the optimal solution, the algorithm reduces the effective search space while maintaining the ability to find the correct k-anonymity solution
2Productivity
If a bottom-up anonymization algorithm prunes generalizations based on a computed lower bound, then it can reduce the search space, but the gap between the lower bound and actual utility is wide at the bottom of the solution space, reducing pruning effectiveness
Solution Approach 1:
The patent pre-computes and stores lower bound values for all nodes before the search begins. This allows the algorithm to use these pre-computed bounds effectively during pruning, even though the bounds are less tight at lower levels. The preliminary computation enables the algorithm to quickly eliminate large portions of the search space without needing to compute bounds on-the-fly
Solution Approach 2:
The algorithm uses the lower bound computations as feedback to guide the search. By comparing pre-computed lower bounds with the current best solution, the algorithm can prune nodes that cannot improve the solution. The feedback mechanism allows the search to focus on promising regions of the lattice while eliminating non-optimal paths
3Power
If distributed systems are used for data anonymization, then computational power is increased, but data transfer overhead becomes excessive
Solution Approach 1:
The patent divides the generalization lattice processing into independent level-by-level computations that can be distributed across multiple processing nodes. Each node processes a subset of nodes at a specific level, and results are aggregated without requiring extensive data transfer. This segmentation allows distributed computation while minimizing communication overhead
Solution Approach 2:
The patent uses pre-computed lower bound values that can be replicated and stored locally at each distributed processing node. Instead of transferring large amounts of data between nodes during computation, each node has access to the necessary bound information locally, significantly reducing data transfer overhead while maintaining computational power
Data Source
AI summary
An approach is disclosed that determines a path through multiple levels of a generalization lattice. The path includes multiple nodes corresponding to the multiple levels, and each of the nodes is determined from a scoring function that utilizes a corresponding parent node that was previously added to the path. The approach then selects an optimal node from the nodes in the path.