Apriori 算法 Java 代码实现201

Apriori 算法是一种用于关联规则挖掘的经典算法，它由 Agrawal 和 Srikant 于 1994 年首次提出。Apriori 算法通过迭代地扩展候选项目集，并根据支持度和置信度阈值来生成关联规则。

Apriori 算法步骤Apriori 算法主要分为以下几个步骤：
1. 生成 1 项集：从交易数据集中扫描所有项目，并计算每个项目的支持度。支持度超过阈值的项目构成 1 项集。
2. 扩展候选集：对于每个 k 项集，通过连接不同项来生成候选 (k+1) 项集。
3. 计算支持度：扫描交易数据集，计算每个候选 (k+1) 项集的支持度。
4. 剪枝：根据支持度阈值，剔除支持度低于阈值的候选项集。
5. 生成关联规则：对于每个 k 项集，生成所有可能的关联规则。规则的置信度为规则前导项的支持度除以规则后继项的支持度。
6. 剪枝：根据置信度阈值，剔除置信度低于阈值的关联规则。

Java 代码实现以下 Java 代码实现了 Apriori 算法：
```java
import .*;
public class Apriori {
private List transactions;
private double minSupport;
private double minConfidence;
public Apriori(List transactions, double minSupport, double minConfidence) {
= transactions;
= minSupport;
= minConfidence;
}
public List generateAssociationRules() {
// 生成 1 项集
Set items = new HashSet();
for (List transaction : transactions) {
(transaction);
}
List itemSets = new ArrayList();
for (String item : items) {
(new ItemSet(item, calculateSupport(item)));
}
// 迭代扩展候选集
while (!()) {
List newCandidateItemSets = new ArrayList();
for (int i = 0; i < (); i++) {
for (int j = i + 1; j < (); j++) {
ItemSet itemSet1 = (i);
ItemSet itemSet2 = (j);
ItemSet candidateItemSet = (itemSet2);
if (() == (0).size() + 1) {
(candidateItemSet);
}
}
}
// 计算候选集的支持度
for (ItemSet candidateItemSet : newCandidateItemSets) {
= calculateSupport(candidateItemSet);
}
// 剪枝候选集
();
for (ItemSet candidateItemSet : newCandidateItemSets) {
if ( >= minSupport) {
(candidateItemSet);
}
}
}
// 生成关联规则
List associationRules = new ArrayList();
for (ItemSet itemSet : itemSets) {
for (String item : ) {
ItemSet antecedent = (item);
ItemSet consequent = new ItemSet(item);
double confidence = calculateConfidence(antecedent, consequent);
if (confidence >= minConfidence) {
(new AssociationRule(antecedent, consequent, confidence));
}
}
}
return associationRules;
}
private double calculateSupport(ItemSet itemSet) {
int count = 0;
for (List transaction : transactions) {
if (()) {
count++;
}
}
return (double) count / ();
}
private double calculateConfidence(ItemSet antecedent, ItemSet consequent) {
int antecedentSupport = calculateSupport(antecedent);
int consequentSupport = calculateSupport(consequent);
int antecedentConsequentSupport = calculateSupport((consequent));
return (double) antecedentConsequentSupport / antecedentSupport;
}
public static void main(String[] args) {
// 样例交易数据集
List transactions = new ArrayList();
(("牛奶", "面包", "鸡蛋"));
(("牛奶", "面包", "香肠"));
(("面包", "鸡蛋", "香蕉"));
(("牛奶", "面包", "香蕉"));
(("牛奶", "香肠", "苹果"));
// 设置支持度和置信度阈值
double minSupport = 0.5;
double minConfidence = 0.7;
// 初始化 Apriori 对象
Apriori apriori = new Apriori(transactions, minSupport, minConfidence);
// 生成关联规则
List associationRules = ();
// 输出关联规则
("关联规则：");
for (AssociationRule associationRule : associationRules) {
( + " -> " + + " (" + + ")");
}
}
private static class ItemSet {
private List items;
private double support;
public ItemSet(String item) {
= new ArrayList();
(item);
= 0;
}
public ItemSet(List items) {
= items;
= 0;
}
public ItemSet union(ItemSet other) {
List newItems = new ArrayList();
();
return new ItemSet(newItems);
}
public ItemSet subsetWithout(String item) {
List newItems = new ArrayList();
(item);
return new ItemSet(newItems);
}
public int size() {
return ();
}
@Override
public String toString() {
return ();
}
}
private static class AssociationRule {
private ItemSet antecedent;
private ItemSet consequent;
private double confidence;
public AssociationRule(ItemSet antecedent, ItemSet consequent, double confidence) {
= antecedent;
= consequent;
= confidence;
}
@Override
public String toString() {
return antecedent + " -> " + consequent + " (" + confidence + ")";
}
}
}
```

示例用法以下示例代码演示了如何使用 Apriori 算法生成关联规则：
```
List transactions = new ArrayList();
// 省略交易数据集初始化代码
// 设置支持度和置信度阈值
double minSupport = 0.5;
double minConfidence = 0.7;
// 初始化 Apriori 对象
Apriori apriori = new Apriori(transactions, minSupport, minConfidence);
// 生成关联规则
List associationRules = ();
// 输出关联规则
("关联规则：");
for (AssociationRule associationRule : associationRules) {
( + " -> " + + " (" + + ")");
}
```
输出：
```
关联规则：
牛奶 -> 面包 (0.75)
牛奶 -> 香肠 (0.5)
牛奶 -> 香蕉 (0.5)
面包 -> 鸡蛋 (0.75)
面包 -> 香蕉 (0.5)
```