46、利用置信度和支持度隐藏关联规则-优快云博客

本文链接：https://blog.youkuaiyun.com/pluto/article/details/149870783

利用置信度和支持度隐藏关联规则

1. 背景与相关工作

数据挖掘（DM）的安全影响受到关注，对于数据挖掘中敏感知识的推理和发现问题，有几种可能的解决方法：
- 模糊源数据库。
- 扩充源数据库。
- 仅发布原始数据的样本，限制对源数据库的访问。

Clifton采用了最后一种方法，研究了发布数据量与发现模式的重要性之间的相关性，并展示了如何确定样本大小，使数据挖掘工具无法获得可靠结果。同时，Clifton和Marks认为研究挖掘算法对于提高处理敏感数据和知识披露限制策略的效率至关重要，分析挖掘技术是维护安全问题的第一步。

除了上述通用方法，还有针对特定数据挖掘算法的解决方案，如关联规则挖掘和分类规则挖掘。分类挖掘算法可能使用敏感数据对对象进行排序，对于基于决策区域的算法，敏感属性每个值生成的描述空间可以预先确定。Johnsten和Raghavan确定了评估分类推理系统输出的两个主要标准，并用于检查和修改敏感对象的描述。Moskowitz和Chang使用基于熵的框架降低数据库推理中敏感信息的等级。

对于基于关联规则检索的挖掘算法，有研究通过降低规则的重要性来防止敏感知识的披露，即减少某些频繁项集的出现次数（支持度），使其低于用户指定的阈值，从而使关联规则挖掘算法无法发现这些规则。

2. 问题描述

设 $I = {i_1, \cdots, i_n}$ 是一组文字，称为项。$D$ 是一个事务数据库，每个事务 $T$ 是一个项集，且 $T \subseteq I$，每个事务有一个唯一标识符TID。如果 $X \subset T$，则称事务 $T$ 支持项集 $X$。

关联规则是形如 $X \Rightarrow Y$ 的蕴含式，其中 $X \subset I$，$Y \subset I$ 且 $X \cap Y = \varnothing$。规则 $X \Rightarrow Y$ 在数据库 $D$ 中以置信度 $c$ 成立，当 $\frac{|X \cup Y|}{|X|} \geq c$；规则 $X \Rightarrow Y$ 具有支持度 $s$，当 $\frac{|X \cup Y|}{N} \geq s$，其中 $N$ 是数据库 $D$ 中的事务数。支持度衡量规则的频率，置信度衡量项集之间关系的强度。

关联规则挖掘算法在搜索项集之间的蕴含关系时依赖支持度和置信度，只检索满足用户要求的一小部分规则，以提高计算效率。

问题可以表述为：给定数据库 $D$、从 $D$ 中挖掘出的相关规则集 $R$ 以及 $R$ 的子集 $R_h$，如何将 $D$ 转换为数据库 $D’$，使得除了 $R_h$ 中的规则外，$R$ 中的其他规则仍能被挖掘出来。解决这个问题是NP难的，因此我们寻求一种将源数据库 $D$ 转换为发布数据库 $D’$ 的方法，以最大化 $R - R_h$ 中仍能被挖掘的规则数量。

隐藏规则集 $R_h$ 有两种主要方法：
- 隐藏规则 $R_h$ 所派生的频繁项集，防止规则生成。
- 将规则的置信度降低到用户指定的阈值（min conf）以下。

3. 示例数据库

以下是一个示例数据库及其相关信息：
| (a) 示例数据库D | |
| — | — |
| TID | Items |
| T1 | ABC |
| T2 | ABC |
| T3 | ABC |
| T4 | AB |
| T5 | A |
| T6 | AC |

(b) 使用提议符号的示例数据库
TID	Items	Size
T1	111	3
T2	111	3
T3	111	3
T4	110	2
T5	100	1
T6	101	2

(c) 大项集
Itemset	Support
A	100%
B	66%
C	66%
AB	66%
AC	66%
BC	50%
ABC	50%

4. 解决方案和算法的假设

在开发算法时，为了简化表示且不失一般性，做出以下假设：
- 通过降低关联规则的支持度或置信度来隐藏规则。
- 根据对非敏感信息的副作用选择降低支持度或置信度。
- 一次隐藏一条规则。
- 每次将支持度或置信度降低一个单位。
- 只隐藏涉及不相交项集的规则。

5. 符号表示

每个数据库事务是一个三元组：$t = $，其中TID是事务的标识符，元素列表为数据库中每个项对应一个元素，若事务支持该项则元素值为1，否则为0，size是元素列表中值为1的元素个数。

若事务 $t$ 的元素列表中对应项集 $S$ 的元素都为1，则 $t$ 支持 $S$；若不全为1，则 $t$ 部分支持 $S$。
降低项集 $S$ 的支持度，选择支持 $S$ 的事务 $t$，将 $t$ 元素列表中对应 $S$ 的非零元素至少一个置为0。
通过部分支持项集 $S$ 的事务 $t$ 增加 $S$ 的支持度，将 $t$ 元素列表中对应 $S$ 的元素都置为1。

6. 三种隐藏策略

给定规则 $X \Rightarrow Y$，其置信度与支持度的关系为：$\text{Conf}(X \Rightarrow Y) = \frac{\text{Supp}(X \cup Y)}{\text{Supp}(X)}$。基于此关系，开发了三种隐藏规则的策略：
1. 降低规则的置信度
- 策略1.a ：通过部分支持 $X$ 和 $Y$ 的事务增加规则前件 $X$ 的支持度。
- 策略1.b ：在支持 $X$ 和 $Y$ 的事务中降低规则后件 $Y$ 的支持度。
2. 降低规则的支持度
- 策略2.a ：降低规则前件 $X$ 或后件 $Y$ 的支持度。

示例：假设数据库 $D$ 如表1 (a) 所示，$\text{min supp} = \frac{2}{6} = 33\%$，$\text{min conf} = 70\%$，要隐藏规则 $AC \Rightarrow B$，其支持度为50%，置信度为75%。
- 策略1.a ：选择事务 $t = $，将对应 $C$ 的元素置为1，得到 $t = $，此时规则 $AC \Rightarrow B$ 的支持度为50%，置信度为60%，规则被隐藏。
- 策略1.b ：选择事务 $t = $，将对应 $B$ 的元素置为0，得到 $t = $，规则 $AC \Rightarrow B$ 的支持度为33%，置信度为50%，规则被隐藏。
- 策略2.a ：选择事务 $t = $，将对应 $C$ 的元素置为0，得到 $t = $，规则 $AC \Rightarrow B$ 的支持度为33%，置信度为66%，规则被隐藏。

7. 算法和数据结构

以下是实现上述策略的算法：
- 算法1.a ：根据策略1.a隐藏敏感规则，增加规则前件的支持度，直到规则置信度低于min conf阈值。

INPUT: 要隐藏的规则集Rh，源数据库D，min conf阈值，min supp阈值
OUTPUT: 转换后的数据库D'，使得Rh中的规则无法被挖掘
BEGIN
    FOREACH rule U IN Rh DO
    {
        REPEAT UNTIL (conf(U) < min conf)
        {
            1. T = { t in D / t partially supports lhs(U) }
            2. count the number of items in each transaction of T
            3. sort the transactions in T in descending order of the number of supported items
            4. choose the transaction t ∈ T with the highest number of items (the first transaction in T )
            5. modify t to support lhs(U)
            6. increase the support of lhs(U) by 1
            7. recompute the confidence of U
        }
        8. remove U from Rh
    }
END

BEGIN
    FOREACH rule U IN Rh DO
    {
        WHILE (conf(U) ≥ min conf)
        {
            T = {t ∈ D / t partially supports lhs(U)}
            // count how many items of lhs(U) are in each trans. of T
            FOREACH transaction t IN T DO
            {
                t.num itmes = |I| - Hamming dist(lhs(U), t.list of items)
            }
            // sort transactions of T in descending order of number of items of lhs(U) contained
            sort(T)
            // pick the transaction of T with the highest number of items
            t = T[1]
            // set to one all the bits of t that represent items in lhs(U)
            set all ones(t.list of items, lhs(U))
            supp(lhs(U)) = supp(lhs(U)) + 1
            conf(U) = supp(U) / supp(lhs(U))
        }
        Rh = Rh - U
    }
END

算法1.b ：根据策略1.b隐藏敏感规则，通过支持规则的事务降低规则后件的频率，直到规则置信度低于最小阈值。

INPUT: 要隐藏的规则集Rh，源数据库D，min conf阈值，min supp阈值
OUTPUT: 转换后的数据库D'，使得Rh中的规则无法被挖掘
BEGIN
    FOREACH rule U IN Rh DO
    {
        REPEAT UNTIL (conf(U) < min conf)
        {
            1. T = { t in D / t supports U }
            2. choose the transaction t in T with the lowest number of items
            3. choose the item j in rhs(U) with the minimum impact on the (|rhs(U)| - 1)-itemsets
            4. delete j from t
            5. decrease the support of U by 1
            6. recompute the confidence of U
        }
        7. remove U from Rh
    }
END

BEGIN
    FOREACH rule U IN Rh DO
    {
        WHILE (conf(U) ≥ min conf)
        {
            T = {t ∈ D / t supports U}
            // sort T in ascending order of size of the transactions and choose the one with the lowest size
            t = choose transaction(T)
            // choose the item of rhs(U) with the minimum impact on the (|rhs(U)| - 1)-itemsets
            j = choose item(rhs(U))
            // set to zero the bit of t.list of items that represents item j
            set to zero(j, t.list of items)
            supp(U) = supp(U) - 1
            conf(U) = supp(U) / supp(lhs(U))
        }
        Rh = Rh - U
    }
END

算法2.a ：降低敏感规则的频率，直到其置信度低于min conf阈值或支持度低于min supp阈值。

以下是从表1 (a) 大项集导出的规则：
| Rules | Confidence | Support |
| — | — | — |
| A ⇒ C | 66% | 66% |
| A ⇒ B | 66% | 66% |
| B ⇒ A | 100% | 66% |
| B ⇒ C | 75% | 50% |
| C ⇒ A | 100% | 66% |
| C ⇒ B | 75% | 50% |
| A ⇒ BC | 50% | 50% |
| B ⇒ AC | 75% | 50% |
| C ⇒ AB | 75% | 50% |
| AB ⇒ C | 75% | 50% |
| AC ⇒ B | 75% | 50% |
| BC ⇒ A | 100% | 50% |

mermaid流程图展示算法1.a的主要流程：

graph TD;
    A[开始] --> B[遍历Rh中的规则U];
    B --> C{conf(U) < min conf?};
    C -- 否 --> D[找出部分支持lhs(U)的事务集T];
    D --> E[统计T中每个事务的项数];
    E --> F[按支持项数降序排序T];
    F --> G[选择T中项数最多的事务t];
    G --> H[修改t以支持lhs(U)];
    H --> I[增加lhs(U)的支持度];
    I --> J[重新计算U的置信度];
    J --> C;
    C -- 是 --> K[从Rh中移除U];
    K --> L{Rh中还有规则?};
    L -- 是 --> B;
    L -- 否 --> M[结束];

利用置信度和支持度隐藏关联规则

8. 算法2.a详细介绍

算法2.a旨在降低敏感规则的频率，直到其置信度低于min conf阈值或支持度低于min supp阈值。以下是该算法的详细步骤：

INPUT: 要隐藏的规则集Rh，源数据库D，min conf阈值，min supp阈值
OUTPUT: 转换后的数据库D'，使得Rh中的规则无法被挖掘
BEGIN
    FOREACH rule U IN Rh DO
    {
        WHILE (conf(U) ≥ min conf AND supp(U) ≥ min supp)
        {
            T = {t ∈ D / t supports U}
            // 按事务大小升序排序T并选择最小的事务
            t = choose transaction(T)
            // 选择rhs(U)中对(|rhs(U)| - 1)-项集影响最小的项
            j = choose item(rhs(U))
            // 将t.list of items中代表项j的位设置为0
            set to zero(j, t.list of items)
            supp(U) = supp(U) - 1
            conf(U) = supp(U) / supp(lhs(U))
        }
        Rh = Rh - U
    }
END

该算法的流程可以用以下mermaid流程图表示：

graph TD;
    A[开始] --> B[遍历Rh中的规则U];
    B --> C{conf(U) ≥ min conf AND supp(U) ≥ min supp?};
    C -- 是 --> D[找出支持U的事务集T];
    D --> E[按事务大小升序排序T并选择最小事务t];
    E --> F[选择rhs(U)中对(|rhs(U)| - 1)-项集影响最小的项j];
    F --> G[将t.list of items中代表项j的位设为0];
    G --> H[减少U的支持度];
    H --> I[重新计算U的置信度];
    I --> C;
    C -- 否 --> J[从Rh中移除U];
    J --> K{Rh中还有规则?};
    K -- 是 --> B;
    K -- 否 --> L[结束];

9. 算法总结与对比

算法	策略	核心操作	适用场景
算法1.a	降低规则置信度（增加前件支持度）	选择部分支持规则前件的事务，增加前件支持度	当增加规则前件支持度对非敏感信息副作用较小时
算法1.b	降低规则置信度（降低后件支持度）	选择支持规则的事务，降低后件支持度	当降低规则后件支持度对非敏感信息副作用较小时
算法2.a	降低规则支持度	选择支持规则的事务，降低规则支持度	当需要同时考虑置信度和支持度阈值，且降低规则支持度对非敏感信息副作用较小时

10. 实际应用考虑

在实际应用中，选择合适的算法和策略需要综合考虑以下因素：
- 数据特点 ：不同的数据集可能对不同的算法有不同的响应。例如，如果数据集中项之间的关联性较强，可能某些算法会更有效。
- 性能要求 ：某些算法可能计算复杂度较高，对于大规模数据集可能需要较长的处理时间。需要根据实际的性能要求选择合适的算法。
- 安全需求 ：根据敏感规则的重要性和安全级别，选择能够有效隐藏规则且对非敏感信息影响最小的算法。