参考资料：http://blog.csdn.net/zone_programming/article/details/42032309
更多数据挖掘代码：https://github.com/linyiqun/DataMiningAlgorithm
介绍
GSP算法是序列模式挖掘算法的一种，他是一种类Apriori的一种，整个过程与Apriori算法比较类似，不过在细节上会略有不同，在下面的描述中，将会有所描述。GSP在原有的频繁模式定义的概念下，增加了3个的概念。1、加入时间约束min_gap，max_gap，要求原来的连续变为只要满足在规定的min_gap到max_gap之间即可。
2、加入time_windows_size，只要在windows_size内的item，都可以被认为是同一ItemSet。
3、加入分类标准。
以上3点新的中的第一条特征将会在后面的算法中着重展现。
算法原理
1、根据所输入的序列，找出所有的单项集，即1频繁模式，这里会经过最小支持度阈值的判断。
2、根据1频繁模式进行连接运算，产生2频繁模式，这里会有进行最小阈值的判断。
3、根据2频繁模式连接产生3频繁模式，会经过最小支持度判断和剪枝操作，剪枝操作的原理在于判断他的所有子集是否也全是频繁模式。
4、3频繁模式不断的挖掘知道不能够产生出候选集为止。
连接操作的原理
2个序列，全部变为item列表的形式，如果a序列去掉第1个元素后，b序列去掉最后1个序列，2个序列的item完全一致，则代表可以连接，由b的最后一个元素加入到a中，至于是以独立项集的身份加入还是加入到a中最后1个项集中取决于b中的最后一个元素所属项集是否为单项项集。
时间约束计算
这个是用在支持度计数使用的，GSP算法的支持度计算不是那么简单，比如序列判断<2, <3, 4>>是否在序列<(1,5), 2 , <3, 4>, 2>，这就不能仅仅判断序列中是否只包含2,<3, 4>就行了，还要满足时间间隔约束，这就要把2，和<3,4>的所有出现时间都找出来，然后再里面找出一条满足时间约束的路径就算包含。时间的定义是从左往右起1.2,3...继续，以1个项集为单位，所有2的时间有2个分别为t=2和t=4，然后同理，因为<3,4>在序列中只有1次，所以时间为t=3，所以问题就变为了下面一个数组的问题
2 4
3
从时间数组的上往下，通过对多个时间的组合，找出1条满足时间约束的方案，这里的方案只有2-3,4-3,然后判断时间间隔，如果存在这样的方式，则代表此序列支持所给定序列，支持度值加1,这个算法在程序的实现中是比较复杂的。
算法的代码实现
测试数据输入(格式：事务ID item数 item1 item2.....):
1 2 1 5
1 1 2
1 1 3
1 1 4
2 1 1
2 1 3
2 1 4
2 2 3 5
3 1 1
3 1 2
3 1 3
3 1 4
3 1 5
4 1 1
4 1 3
4 1 5
5 1 4
5 1 5<(1,5) 2 3 4>
<1 3 4 (3,5)>
<1 2 3 4 5>
<1 3 5>
<4 5>
也就是说同一序列都是同事务的。下面是关键的类
Sequence.java:
package DataMining_GSP;
import java.util.ArrayList;
/**
* 序列，每个序列内部包含多组ItemSet项集
*
* @author lyq
*
*/
public class Sequence implements Comparable<Sequence>, Cloneable {
// 序列所属事务ID
private int trsanctionID;
// 项集列表
private ArrayList<ItemSet> itemSetList;
public Sequence(int trsanctionID) {
this.trsanctionID = trsanctionID;
this.itemSetList = new ArrayList<>();
}
public Sequence() {
this.itemSetList = new ArrayList<>();
}
public int getTrsanctionID() {
return trsanctionID;
}
public void setTrsanctionID(int trsanctionID) {
this.trsanctionID = trsanctionID;
}
public ArrayList<ItemSet> getItemSetList() {
return itemSetList;
}
public void setItemSetList(ArrayList<ItemSet> itemSetList) {
this.itemSetList = itemSetList;
}
/**
* 取出序列中第一个项集的第一个元素
*
* @return
*/
public Integer getFirstItemSetNum() {
return this.getItemSetList().get(0).getItems().get(0);
}
/**
* 获取序列中最后一个项集
*
* @return
*/
public ItemSet getLastItemSet() {
return getItemSetList().get(getItemSetList().size() - 1);
}
/**
* 获取序列中最后一个项集的最后一个一个元素
*
* @return
*/
public Integer getLastItemSetNum() {
ItemSet lastItemSet = getItemSetList().get(getItemSetList().size() - 1);
int lastItemNum = lastItemSet.getItems().get(
lastItemSet.getItems().size() - 1);
return lastItemNum;
}
/**
* 判断序列中最后一个项集是否为单一的值
*
* @return
*/
public boolean isLastItemSetSingleNum() {
ItemSet lastItemSet = getItemSetList().get(getItemSetList().size() - 1);
int size = lastItemSet.getItems().size();
return size == 1 ? true : false;
}
@Override
public int compareTo(Sequence o) {
// TODO Auto-generated method stub
return this.getFirstItemSetNum().compareTo(o.getFirstItemSetNum());
}
@Override
protected Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
/**
* 拷贝一份一模一样的序列
*/
public Sequence copySeqence(){
Sequence copySeq = new Sequence();
for(ItemSet itemSet: this.itemSetList){
copySeq.getItemSetList().add(new ItemSet(itemSet.copyItems()));
}
return copySeq;
}
/**
* 比较2个序列是否相等，需要判断内部的每个项集是否完全一致
*
* @param seq
* 比较的序列对象
* @return
*/
public boolean compareIsSame(Sequence seq) {
boolean result = true;
ArrayList<ItemSet> itemSetList2 = seq.getItemSetList();
ItemSet tempItemSet1;
ItemSet tempItemSet2;
if (itemSetList2.size() != this.itemSetList.size()) {
return false;
}
for (int i = 0; i < itemSetList2.size(); i++) {
tempItemSet1 = this.itemSetList.get(i);
tempItemSet2 = itemSetList2.get(i);
if (!tempItemSet1.compareIsSame(tempItemSet2)) {
// 只要不相等，直接退出函数
result = false;
break;
}
}
return result;
}
/**
* 生成此序列的所有子序列
*
* @return
*/
public ArrayList<Sequence> createChildSeqs() {
ArrayList<Sequence> childSeqs = new ArrayList<>();
ArrayList<Integer> tempItems;
Sequence tempSeq = null;
ItemSet tempItemSet;
for (int i = 0; i < this.itemSetList.size(); i++) {
tempItemSet = itemSetList.get(i);
if (tempItemSet.getItems().size() == 1) {
tempSeq = this.copySeqence();
// 如果只有项集中只有1个元素，则直接移除
tempSeq.itemSetList.remove(i);
childSeqs.add(tempSeq);
} else {
tempItems = tempItemSet.getItems();
for (int j = 0; j < tempItems.size(); j++) {
tempSeq = this.copySeqence();
// 在拷贝的序列中移除一个数字
tempSeq.getItemSetList().get(i).getItems().remove(j);
childSeqs.add(tempSeq);
}
}
}
return childSeqs;
}
}
package DataMining_GSP;
import java.util.ArrayList;
/**
* 序列中的子项集
*
* @author lyq
*
*/
public class ItemSet {
/**
* 项集中保存的是数字项数组
*/
private ArrayList<Integer> items;
public ItemSet(String[] itemStr) {
items = new ArrayList<>();
for (String s : itemStr) {
items.add(Integer.parseInt(s));
}
}
public ItemSet(int[] itemNum) {
items = new ArrayList<>();
for (int num : itemNum) {
items.add(num);
}
}
public ItemSet(ArrayList<Integer> itemNum) {
this.items = itemNum;
}
public ArrayList<Integer> getItems() {
return items;
}
public void setItems(ArrayList<Integer> items) {
this.items = items;
}
/**
* 判断2个项集是否相等
*
* @param itemSet
* 比较对象
* @return
*/
public boolean compareIsSame(ItemSet itemSet) {
boolean result = true;
if (this.items.size() != itemSet.items.size()) {
return false;
}
for (int i = 0; i < itemSet.items.size(); i++) {
if (this.items.get(i) != itemSet.items.get(i)) {
// 只要有值不相等，直接算作不相等
result = false;
break;
}
}
return result;
}
/**
* 拷贝项集中同样的数据一份
*
* @return
*/
public ArrayList<Integer> copyItems() {
ArrayList<Integer> copyItems = new ArrayList<>();
for (int num : this.items) {
copyItems.add(num);
}
return copyItems;
}
}
package DataMining_GSP;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* GSP序列模式分析算法
*
* @author lyq
*
*/
public class GSPTool {
// 测试数据文件地址
private String filePath;
// 最小支持度阈值
private int minSupportCount;
// 时间最小间隔
private int min_gap;
// 时间最大间隔
private int max_gap;
// 原始数据序列
private ArrayList<Sequence> totalSequences;
// GSP算法中产生的所有的频繁项集序列
private ArrayList<Sequence> totalFrequencySeqs;
// 序列项数字对时间的映射图容器
private ArrayList<ArrayList<HashMap<Integer, Integer>>> itemNum2Time;
public GSPTool(String filePath, int minSupportCount, int min_gap,
int max_gap) {
this.filePath = filePath;
this.minSupportCount = minSupportCount;
this.min_gap = min_gap;
this.max_gap = max_gap;
totalFrequencySeqs = new ArrayList<>();
readDataFile();
}
/**
* 从文件中读取数据
*/
private void readDataFile() {
File file = new File(filePath);
ArrayList<String[]> dataArray = new ArrayList<String[]>();
try {
BufferedReader in = new BufferedReader(new FileReader(file));
String str;
String[] tempArray;
while ((str = in.readLine()) != null) {
tempArray = str.split(" ");
dataArray.add(tempArray);
}
in.close();
} catch (IOException e) {
e.getStackTrace();
}
HashMap<Integer, Sequence> mapSeq = new HashMap<>();
Sequence seq;
ItemSet itemSet;
int tID;
String[] itemStr;
for (String[] str : dataArray) {
tID = Integer.parseInt(str[0]);
itemStr = new String[Integer.parseInt(str[1])];
System.arraycopy(str, 2, itemStr, 0, itemStr.length);
itemSet = new ItemSet(itemStr);
if (mapSeq.containsKey(tID)) {
seq = mapSeq.get(tID);
} else {
seq = new Sequence(tID);
}
seq.getItemSetList().add(itemSet);
mapSeq.put(tID, seq);
}
// 将序列图加入到序列List中
totalSequences = new ArrayList<>();
for (Map.Entry entry : mapSeq.entrySet()) {
totalSequences.add((Sequence) entry.getValue());
}
}
/**
* 生成1频繁项集
*
* @return
*/
private ArrayList<Sequence> generateOneFrequencyItem() {
int count = 0;
int currentTransanctionID = 0;
Sequence tempSeq;
ItemSet tempItemSet;
HashMap<Integer, Integer> itemNumMap = new HashMap<>();
ArrayList<Sequence> seqList = new ArrayList<>();
for (Sequence seq : totalSequences) {
for (ItemSet itemSet : seq.getItemSetList()) {
for (int num : itemSet.getItems()) {
// 如果没有此种类型项，则进行添加操作
if (!itemNumMap.containsKey(num)) {
itemNumMap.put(num, 1);
}
}
}
}
boolean isContain = false;
int number = 0;
for (Map.Entry entry : itemNumMap.entrySet()) {
count = 0;
number = (int) entry.getKey();
for (Sequence seq : totalSequences) {
isContain = false;
for (ItemSet itemSet : seq.getItemSetList()) {
for (int num : itemSet.getItems()) {
if (num == number) {
isContain = true;
break;
}
}
if(isContain){
break;
}
}
if(isContain){
count++;
}
}
itemNumMap.put(number, count);
}
for (Map.Entry entry : itemNumMap.entrySet()) {
count = (int) entry.getValue();
if (count >= minSupportCount) {
tempSeq = new Sequence();
tempItemSet = new ItemSet(new int[] { (int) entry.getKey() });
tempSeq.getItemSetList().add(tempItemSet);
seqList.add(tempSeq);
}
}
// 将序列升序排列
Collections.sort(seqList);
// 将频繁1项集加入总频繁项集列表中
totalFrequencySeqs.addAll(seqList);
return seqList;
}
/**
* 通过1频繁项集连接产生2频繁项集
*
* @param oneSeq
* 1频繁项集序列
* @return
*/
private ArrayList<Sequence> generateTwoFrequencyItem(
ArrayList<Sequence> oneSeq) {
Sequence tempSeq;
ArrayList<Sequence> resultSeq = new ArrayList<>();
ItemSet tempItemSet;
int num1;
int num2;
// 假如将<a>,<b>2个1频繁项集做连接组合，可以分为<a a>，<a b>，<b a>,<b b>4个序列模式
// 注意此时的每个序列中包含2个独立项集
for (int i = 0; i < oneSeq.size(); i++) {
num1 = oneSeq.get(i).getFirstItemSetNum();
for (int j = 0; j < oneSeq.size(); j++) {
num2 = oneSeq.get(j).getFirstItemSetNum();
tempSeq = new Sequence();
tempItemSet = new ItemSet(new int[] { num1 });
tempSeq.getItemSetList().add(tempItemSet);
tempItemSet = new ItemSet(new int[] { num2 });
tempSeq.getItemSetList().add(tempItemSet);
if (countSupport(tempSeq) >= minSupportCount) {
resultSeq.add(tempSeq);
}
}
}
// 上面连接还有1种情况是每个序列中只包含有一个项集的情况，此时a,b的划分则是<(a,a)> <(a,b)> <(b,b)>
for (int i = 0; i < oneSeq.size(); i++) {
num1 = oneSeq.get(i).getFirstItemSetNum();
for (int j = i; j < oneSeq.size(); j++) {
num2 = oneSeq.get(j).getFirstItemSetNum();
tempSeq = new Sequence();
tempItemSet = new ItemSet(new int[] { num1, num2 });
tempSeq.getItemSetList().add(tempItemSet);
if (countSupport(tempSeq) >= minSupportCount) {
resultSeq.add(tempSeq);
}
}
}
// 同样将2频繁项集加入到总频繁项集中
totalFrequencySeqs.addAll(resultSeq);
return resultSeq;
}
/**
* 根据上次的频繁集连接产生新的侯选集
*
* @param seqList
* 上次产生的候选集
* @return
*/
private ArrayList<Sequence> generateCandidateItem(
ArrayList<Sequence> seqList) {
Sequence tempSeq;
ArrayList<Integer> tempNumArray;
ArrayList<Sequence> resultSeq = new ArrayList<>();
// 序列数字项列表
ArrayList<ArrayList<Integer>> seqNums = new ArrayList<>();
for (int i = 0; i < seqList.size(); i++) {
tempNumArray = new ArrayList<>();
tempSeq = seqList.get(i);
for (ItemSet itemSet : tempSeq.getItemSetList()) {
tempNumArray.addAll(itemSet.copyItems());
}
seqNums.add(tempNumArray);
}
ArrayList<Integer> array1;
ArrayList<Integer> array2;
// 序列i,j的拷贝
Sequence seqi = null;
Sequence seqj = null;
// 判断是否能够连接，默认能连接
boolean canConnect = true;
// 进行连接运算，包括自己与自己连接
for (int i = 0; i < seqNums.size(); i++) {
for (int j = 0; j < seqNums.size(); j++) {
array1 = (ArrayList<Integer>) seqNums.get(i).clone();
array2 = (ArrayList<Integer>) seqNums.get(j).clone();
// 将第一个数字组去掉第一个，第二个数字组去掉最后一个，如果剩下的部分相等，则可以连接
array1.remove(0);
array2.remove(array2.size() - 1);
canConnect = true;
for (int k = 0; k < array1.size(); k++) {
if (array1.get(k) != array2.get(k)) {
canConnect = false;
break;
}
}
if (canConnect) {
seqi = seqList.get(i).copySeqence();
seqj = seqList.get(j).copySeqence();
int lastItemNum = seqj.getLastItemSetNum();
if (seqj.isLastItemSetSingleNum()) {
// 如果j序列的最后项集为单一值，则最后一个数字以独立项集加入i序列
ItemSet itemSet = new ItemSet(new int[] { lastItemNum });
seqi.getItemSetList().add(itemSet);
} else {
// 如果j序列的最后项集为非单一值，则最后一个数字加入i序列最后一个项集中
ItemSet itemSet = seqi.getLastItemSet();
itemSet.getItems().add(lastItemNum);
}
// 判断是否超过最小支持度阈值
if (isChildSeqContained(seqi)
&& countSupport(seqi) >= minSupportCount) {
resultSeq.add(seqi);
}
}
}
}
totalFrequencySeqs.addAll(resultSeq);
return resultSeq;
}
/**
* 判断此序列的所有子序列是否也是频繁序列
*
* @param seq
* 待比较序列
* @return
*/
private boolean isChildSeqContained(Sequence seq) {
boolean isContained = false;
ArrayList<Sequence> childSeqs;
childSeqs = seq.createChildSeqs();
for (Sequence tempSeq : childSeqs) {
isContained = false;
for (Sequence frequencySeq : totalFrequencySeqs) {
if (tempSeq.compareIsSame(frequencySeq)) {
isContained = true;
break;
}
}
if (!isContained) {
break;
}
}
return isContained;
}
/**
* 候选集判断支持度的值
*
* @param seq
* 待判断序列
* @return
*/
private int countSupport(Sequence seq) {
int count = 0;
int matchNum = 0;
Sequence tempSeq;
ItemSet tempItemSet;
HashMap<Integer, Integer> timeMap;
ArrayList<ItemSet> itemSetList;
ArrayList<ArrayList<Integer>> numArray = new ArrayList<>();
// 每项集对应的时间链表
ArrayList<ArrayList<Integer>> timeArray = new ArrayList<>();
for (ItemSet itemSet : seq.getItemSetList()) {
numArray.add(itemSet.getItems());
}
for (int i = 0; i < totalSequences.size(); i++) {
timeArray = new ArrayList<>();
for (int s = 0; s < numArray.size(); s++) {
ArrayList<Integer> childNum = numArray.get(s);
ArrayList<Integer> localTime = new ArrayList<>();
tempSeq = totalSequences.get(i);
itemSetList = tempSeq.getItemSetList();
for (int j = 0; j < itemSetList.size(); j++) {
tempItemSet = itemSetList.get(j);
matchNum = 0;
int t = 0;
if (tempItemSet.getItems().size() == childNum.size()) {
timeMap = itemNum2Time.get(i).get(j);
// 只有当项集长度匹配时才匹配
for (int k = 0; k < childNum.size(); k++) {
if (timeMap.containsKey(childNum.get(k))) {
matchNum++;
t = timeMap.get(childNum.get(k));
}
}
// 如果完全匹配，则记录时间
if (matchNum == childNum.size()) {
localTime.add(t);
}
}
}
if (localTime.size() > 0) {
timeArray.add(localTime);
}
}
// 判断时间是否满足时间最大最小约束，如果满足，则此条事务包含候选事务
if (timeArray.size() == numArray.size()
&& judgeTimeInGap(timeArray)) {
count++;
}
}
return count;
}
/**
* 判断事务是否满足时间约束
*
* @param timeArray
* 时间数组，每行代表各项集的在事务中的发生时间链表
* @return
*/
private boolean judgeTimeInGap(ArrayList<ArrayList<Integer>> timeArray) {
boolean result = false;
int preTime = 0;
ArrayList<Integer> firstTimes = timeArray.get(0);
timeArray.remove(0);
if (timeArray.size() == 0) {
return false;
}
for (int i = 0; i < firstTimes.size(); i++) {
preTime = firstTimes.get(i);
if (dfsJudgeTime(preTime, timeArray)) {
result = true;
break;
}
}
return result;
}
/**
* 深度优先遍历时间，判断是否有符合条件的时间间隔
*
* @param preTime
* @param timeArray
* @return
*/
private boolean dfsJudgeTime(int preTime,
ArrayList<ArrayList<Integer>> timeArray) {
boolean result = false;
ArrayList<ArrayList<Integer>> timeArrayClone = (ArrayList<ArrayList<Integer>>) timeArray
.clone();
ArrayList<Integer> firstItemItem = timeArrayClone.get(0);
for (int i = 0; i < firstItemItem.size(); i++) {
if (firstItemItem.get(i) - preTime >= min_gap
&& firstItemItem.get(i) - preTime <= max_gap) {
// 如果此2项间隔时间满足时间约束，则继续往下递归
preTime = firstItemItem.get(i);
timeArrayClone.remove(0);
if (timeArrayClone.size() == 0) {
return true;
} else {
result = dfsJudgeTime(preTime, timeArrayClone);
if (result) {
return true;
}
}
}
}
return result;
}
/**
* 初始化序列项到时间的序列图，为了后面的时间约束计算
*/
private void initItemNumToTimeMap() {
Sequence seq;
itemNum2Time = new ArrayList<>();
HashMap<Integer, Integer> tempMap;
ArrayList<HashMap<Integer, Integer>> tempMapList;
for (int i = 0; i < totalSequences.size(); i++) {
seq = totalSequences.get(i);
tempMapList = new ArrayList<>();
for (int j = 0; j < seq.getItemSetList().size(); j++) {
ItemSet itemSet = seq.getItemSetList().get(j);
tempMap = new HashMap<>();
for (int itemNum : itemSet.getItems()) {
tempMap.put(itemNum, j + 1);
}
tempMapList.add(tempMap);
}
itemNum2Time.add(tempMapList);
}
}
/**
* 进行GSP算法计算
*/
public void gspCalculate() {
ArrayList<Sequence> oneSeq;
ArrayList<Sequence> twoSeq;
ArrayList<Sequence> candidateSeq;
initItemNumToTimeMap();
oneSeq = generateOneFrequencyItem();
twoSeq = generateTwoFrequencyItem(oneSeq);
candidateSeq = twoSeq;
// 不断连接生产候选集，直到没有产生出侯选集
for (;;) {
candidateSeq = generateCandidateItem(candidateSeq);
if (candidateSeq.size() == 0) {
break;
}
}
outputSeqence(totalFrequencySeqs);
}
/**
* 输出序列列表信息
*
* @param outputSeqList
* 待输出序列列表
*/
private void outputSeqence(ArrayList<Sequence> outputSeqList) {
for (Sequence seq : outputSeqList) {
System.out.print("<");
for (ItemSet itemSet : seq.getItemSetList()) {
System.out.print("(");
for (int num : itemSet.getItems()) {
System.out.print(num + ",");
}
System.out.print("), ");
}
System.out.println(">");
}
}
}
package DataMining_GSP;
/**
* GSP序列模式分析算法
* @author lyq
*
*/
public class Client {
public static void main(String[] args){
String filePath = "C:\Users\lyq\Desktop\icon\testInput.txt";
//最小支持度阈值
int minSupportCount = 2;
//时间最小间隔
int min_gap = 1;
//施加最大间隔
int max_gap = 5;
GSPTool tool = new GSPTool(filePath, minSupportCount, min_gap, max_gap);
tool.gspCalculate();
}
}
<(1,), >
<(2,), >
<(3,), >
<(4,), >
<(5,), >
<(1,), (3,), >
<(1,), (4,), >
<(1,), (5,), >
<(2,), (3,), >
<(2,), (4,), >
<(3,), (4,), >
<(3,), (5,), >
<(4,), (5,), >
<(1,), (3,), (4,), >
<(1,), (3,), (5,), >
<(2,), (3,), (4,), >算法实现的难点
1、算法花费了几天的时间，难点首先在于对算法原理本身的理解，网上对于此算法的资料特别少，而且不同的人所表达的意思 都有少许的不同，讲的也不是很详细，于是就通过阅读别人的代码理解GSP算法的原理，我的代码实现也是参考了参考资料的C语言的实现。
2、在实现时间约束的支持度计数统计的时候，调试了一段时间，做时间统计容易出错，因为层级实在太多容易搞晕。
3、还有1个是Sequence和ItemSet的拷贝时的引用问题，在产生新的序列时一定要深拷贝1个否则导致同一引用会把原数据给改掉的。
GSP算法和Apriori算法的比较
我是都实现过了GSP算法和Apriori算法的，后者是被称为关联规则挖掘算法，偏向于挖掘关联规则的，2个算法在连接的操作上有不一样的地方，还有在数据的构成方式上，Apriori的数据会简单一点，都是单项单项构成的，而且在做支持度统计的时候只需判断存在与否即可。不需要考虑时间约束。Apriori算法给定K项集，连接到K-1项集算法就停止了，而GSP算法是直到不能够产生候选集为止。