GSP算法

最新推荐文章于 2024-01-10 00:43:44 发布
最新推荐文章于 2024-01-10 00:43:44 发布
阅读量398 收藏 4
点赞数
文章标签： 算法 python 数据挖掘
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50924532/article/details/130951926
版权

GSP算法
nav

第1关：候选产生

import itertools
import datetime
 

class Base(object):
    def __init__(self):
        self.queue = []


    def freq1(self, data, frequent_num):
        appear = ''
        freq1 = []
        appear_ele = []
        appear_ele2 = []
        for i in range(len(data)):
            appear = ''
            for j in range(len(data[i])):
                appear += data[i][j]
            appear_ele += list(set(appear))
            print(appear_ele)
        #print(appear_ele)
        appear_ele2 = list(set(appear_ele))
        print(appear_ele2)
        for item in appear_ele2:
            itmes = appear_ele.count(item)
            if itmes >= frequent_num:
                freq1.append(item)
        print('频繁1项集为:%s' % freq1)
        return freq1


    def freq_more(self, data, freq1):
          
        # 候选生成
        queue = []  # 所有的备选序列放在这里面
        queue_new = []  # 最终结果在这里面
        top = 0  # 这个是queue_new的队尾标号
        times = 3
        while True:

            ####################Begin################
            if (queue_new == []):  # 为空则代表这是第一次遍历,python中的&&是and,||是or
                for i in range(len(freq1)):
                    for j in range(i + 1, len(freq1)):
                        item = freq1[i] + freq1[j]
                        queue.append(item)  # 枚举所有可能出现的二项 即同时出现的二项
                for i in range(len(freq1)):
                    for j in range(len(freq1)):
                        if j != i:
                            item = freq1[i] + '->' + freq1[j]
                            queue.append(item)  # 第一次遍历后全部可能出现的情况 # 枚举非同时，含有时序信息的二项
                for i in range(len(queue)):
                    freq_item = self.isFreq(queue[i], data)
                    if freq_item != 0:
                        queue_new.append(freq_item)
                queue = []  # 清空queue(备选序列)
            if (queue_new != []):  # 后几次遍历时要把所有的情况写入空的queue中
                if top == len(queue_new) - 1:  # 表示没有新加入元素，那么终止 while 循环
                    print('频繁多项集为:%s' % queue_new)
                    break
                else:
                    demo_list = []  # 专门放'AB','BF','AF'这样的频繁序列，后面将他们合成为更多成员的备选频繁序列
                    for i in range(top, len(queue_new)):
                        if '->' not in queue_new[i]:
                            demo_list.append(queue_new[i])
                    demo_string = self.List_to_String(
                        demo_list)  # 将列表中的元素拼接成字符串，诸如拼成'ABBFAF'
                    demo_ele = "".join(set(demo_string))  # 删除串中的重复元素,输出'ABF'
                    if len(demo_ele) >= times:
                        if len(demo_ele) == times:  # 那么demo_ele是唯一的备选成员
                            queue.append(demo_ele)
                            times += 1
                        # 否则对备选字母进行排列组合，比如'ABCDE'，一共能排列出10钟情况，并把它们推入queue(待判断成员队列)
                        else:
                            combin = self.Combinations(demo_ele, times)
                            for i in range(len(combin)):
                                queue.append(combin[i])
                            times += 1
                    ###-----####至此已经把备选频繁寻列推入 queue ####-----###
                    queue = self.Make_time_queue(top, freq1, queue, queue_new)
                    ###-----#### 至此已经把 queue 放满了备选成员 ####-----###
                    top = len(queue_new)  # 更新队尾指针 top 的位置

                    #####################End################
                            
                    # 候选剪枝
                    ###-----#### 检测 queue 中的备选序列是否频繁 ####-----###
                    for i in range(len(queue)):
                        freq_item = self.isFreq( 
                            queue[i], data)  # ---->> isFreq
                        if freq_item != 0:  # 如果这个成员是频繁的
                            queue_new.append(freq_item)
                    queue = []

第二关

import itertools
import datetime
 
class Base(object):
    def __init__(self):
        self.queue = []
    def freq1(self, data, frequent_num):
        appear = ''
        freq1 = []
        appear_ele = []
        appear_ele2 = []
        for i in range(len(data)):
            appear = ''
            for j in range(len(data[i])):
                appear += data[i][j]
            appear_ele += list(set(appear))
            print(appear_ele)
        #print(appear_ele)
        appear_ele2 = list(set(appear_ele))
        print(appear_ele2)
        for item in appear_ele2:
            itmes = appear_ele.count(item)
            if itmes >= frequent_num:
                freq1.append(item)
        print('频繁1项集为:%s' % freq1)
        return freq1
    def freq_more(self, data, freq1):
        # 候选生成
        queue = []  # 所有的备选序列放在这里面
        queue_new = []  # 最终结果在这里面
        top = 0  # 这个是queue_new的队尾标号
        times = 3
        while True:
            if (queue_new == []):  # 为空则代表这是第一次遍历,python中的&&是and,||是or
                for i in range(len(freq1)):
                    for j in range(i + 1, len(freq1)):
                        item = freq1[i] + freq1[j]
                        queue.append(item)  # 枚举所有可能出现的二项 即同时出现的二项
                for i in range(len(freq1)):
                    for j in range(len(freq1)):
                        if j != i:
                            item = freq1[i] + '->' + freq1[j]
                            queue.append(item)  # 第一次遍历后全部可能出现的情况 # 枚举非同时，含有时序信息的二项
                for i in range(len(queue)):
                    freq_item = self.isFreq(queue[i], data)
                    if freq_item != 0:
                        queue_new.append(freq_item)
                queue = []  # 清空queue(备选序列)
            if (queue_new != []):  # 后几次遍历时要把所有的情况写入空的queue中
                if top == len(queue_new) - 1:  # 表示没有新加入元素，那么终止 while 循环
                    print('频繁多项集为:%s' % queue_new)
                    break
                else:
                    demo_list = []  # 专门放'AB','BF','AF'这样的频繁序列，后面将他们合成为更多成员的备选频繁序列
                    for i in range(top, len(queue_new)):
                        if '->' not in queue_new[i]:
                            demo_list.append(queue_new[i])
                    demo_string = self.List_to_String(
                        demo_list)  # 将列表中的元素拼接成字符串，诸如拼成'ABBFAF'
                    demo_ele = "".join(set(demo_string))  # 删除串中的重复元素,输出'ABF'
                    if len(demo_ele) >= times:
                        if len(demo_ele) == times:  # 那么demo_ele是唯一的备选成员
                            queue.append(demo_ele)
                            times += 1
                        # 否则对备选字母进行排列组合，比如'ABCDE'，一共能排列出10钟情况，并把它们推入queue(待判断成员队列)
                        else:
                            combin = self.Combinations(demo_ele, times)
                            for i in range(len(combin)):
                                queue.append(combin[i])
                            times += 1
                    ###-----####至此已经把备选频繁寻列推入 queue ####-----###
                    queue = self.Make_time_queue(top, freq1, queue, queue_new)
                    ###-----#### 至此已经把 queue 放满了备选成员 ####-----###
                    top = len(queue_new)  # 更新队尾指针 top 的位置
                    ############Begin##########
                    # 候选剪枝
                    ###-----#### 检测 queue 中的备选序列是否频繁 ####-----###
                    for i in range(len(queue)):
                        freq_item = self.isFreq( 
                            queue[i], data)  # ---->> isFreq
                        if freq_item != 0:  # 如果这个成员是频繁的
                            queue_new.append(freq_item)
                    queue = []
                    ############End##########

第三关

import itertools
import datetime
 
class Base(object):
    def __init__(self):
        self.queue = []
    def freq1(self, data, frequent_num):
        appear = ''
        freq1 = []
        appear_ele = []
        appear_ele2 = []
        for i in range(len(data)):
            appear = ''
            for j in range(len(data[i])):
                appear += data[i][j]
            appear_ele += list(set(appear))
            print(appear_ele)
        #print(appear_ele)
        appear_ele2 = list(set(appear_ele))
        print(appear_ele2)
        for item in appear_ele2:
            itmes = appear_ele.count(item)
            if itmes >= frequent_num:
                freq1.append(item)
        print('频繁1项集为:%s' % freq1)
        return freq1
    def freq_more(self, data, freq1):
        # 候选生成
        queue = []  # 所有的备选序列放在这里面
        queue_new = []  # 最终结果在这里面
        top = 0  # 这个是queue_new的队尾标号
        times = 3
        while True:
            if (queue_new == []):  # 为空则代表这是第一次遍历,python中的&&是and,||是or
                for i in range(len(freq1)):
                    for j in range(i + 1, len(freq1)):
                        item = freq1[i] + freq1[j]
                        queue.append(item)  # 枚举所有可能出现的二项 即同时出现的二项
                for i in range(len(freq1)):
                    for j in range(len(freq1)):
                        if j != i:
                            item = freq1[i] + '->' + freq1[j]
                            queue.append(item)  # 第一次遍历后全部可能出现的情况 # 枚举非同时，含有时序信息的二项
                for i in range(len(queue)):
                    freq_item = self.isFreq(queue[i], data)
                    if freq_item != 0:
                        queue_new.append(freq_item)
                queue = []  # 清空queue(备选序列)
            if (queue_new != []):  # 后几次遍历时要把所有的情况写入空的queue中
                if top == len(queue_new) - 1:  # 表示没有新加入元素，那么终止 while 循环
                    print('频繁多项集为:%s' % queue_new)
                    break
                else:
                    demo_list = []  # 专门放'AB','BF','AF'这样的频繁序列，后面将他们合成为更多成员的备选频繁序列
                    for i in range(top, len(queue_new)):
                        if '->' not in queue_new[i]:
                            demo_list.append(queue_new[i])
                    demo_string = self.List_to_String(
                        demo_list)  # 将列表中的元素拼接成字符串，诸如拼成'ABBFAF'
                    demo_ele = "".join(set(demo_string))  # 删除串中的重复元素,输出'ABF'
                    if len(demo_ele) >= times:
                        if len(demo_ele) == times:  # 那么demo_ele是唯一的备选成员
                            queue.append(demo_ele)
                            times += 1
                        # 否则对备选字母进行排列组合，比如'ABCDE'，一共能排列出10钟情况，并把它们推入queue(待判断成员队列)
                        else:
                            combin = self.Combinations(demo_ele, times)
                            for i in range(len(combin)):
                                queue.append(combin[i])
                            times += 1
                    ###-----####至此已经把备选频繁寻列推入 queue ####-----###
                    queue = self.Make_time_queue(top, freq1, queue, queue_new)
                    ###-----#### 至此已经把 queue 放满了备选成员 ####-----###
                    top = len(queue_new)  # 更新队尾指针 top 的位置
                    # 候选剪枝
                    ###-----#### 检测 queue 中的备选序列是否频繁 ####-----###
                    for i in range(len(queue)):
                        freq_item = self.isFreq( 
                            queue[i], data)  # ---->> isFreq
                        if freq_item != 0:  # 如果这个成员是频繁的
                            queue_new.append(freq_item)
                    queue = []
    # 将列表中的字母合并成字符串   # 这个函数可以省略
    def List_to_String(self, list):
        demo_string = ''
        for i in range(len(list)):
            demo_string = demo_string + list[i]
        return demo_string
    #demo_ele是待排列的字符串, times是将它们排列成几个元素
    def Combinations(self, item, times):
        demo_list = []
        combin = []
        element = ''
        for i in range(1, len(item) + 1):
            iter = itertools.combinations(item, i)
            demo_list.append(list(iter))
        demo_combin = demo_list[times - 1]
        for i in range(len(demo_combin)):
            for j in range(len(demo_combin[0])):
                element += demo_combin[i][j]
            combin.append(element)
            element = ''
        return combin
    # 判断 item 是否在 data[i][j]中
    def isIn_Item(self, item, data, i, j):
        demo_num = 0
        for k in range(len(item)):
            if item[k] in data[i][j]:
                demo_num += 1
        if demo_num == len(item):
            return 1
        else:
            return 0
    def isFreq(self, item, data):
        #############Begin#############
        # 支持度计算 
        num = 0
        if '->' not in item:  # 类似如'ABF'
            for i in range(len(data)):
                for j in range(len(data[i])):
                    if self.isIn_Item(item, data, i, j) != 0:
                        num += 1
            if num >= 2:
                return item
            else:
                return 0
        else:  # 类似如‘D->B->A’
            item0 = item.split('->')   # 将item分割成一个list
            for i in range(len(data)):
                array = 0
                j = 0
                while True:
                    if array == len(item0) or j == len(data[i]):
                        break
                    if len(item0[array]) >= 2:  # 如果类似 'BA' 形式
                        if self.isIn_Item(item0[array], data, i, j) == 1: 
                            array += 1
                            j += 1
                        else:
                            j += 1
                    else:
                        if item0[array] in data[i][j]:
                            array += 1
                            j += 1
                        else:
                            j += 1
                if array == len(item0):
                    num += 1
            if num >= 2:
                return item
            else:
                return 0
        #################End####################

第四关

import itertools
import datetime
 
class Base(object):
    def __init__(self):
        self.queue = []
    def freq1(self, data, frequent_num):
        appear = ''
        freq1 = []
        appear_ele = []
        appear_ele2 = []
        for i in range(len(data)):
            appear = ''
            for j in range(len(data[i])):
                appear += data[i][j]
            appear_ele += list(set(appear))
            print(appear_ele)
        #print(appear_ele)
        appear_ele2 = list(set(appear_ele))
        print(appear_ele2)
        for item in appear_ele2:
            itmes = appear_ele.count(item)
            if itmes >= frequent_num:
                freq1.append(item)
        print('频繁1项集为:%s' % freq1)
        return freq1
    def freq_more(self, data, freq1):
        # 候选生成
        queue = []  # 所有的备选序列放在这里面
        queue_new = []  # 最终结果在这里面
        top = 0  # 这个是queue_new的队尾标号
        times = 3
        while True:
            if (queue_new == []):  # 为空则代表这是第一次遍历,python中的&&是and,||是or
                for i in range(len(freq1)):
                    for j in range(i + 1, len(freq1)):
                        item = freq1[i] + freq1[j]
                        queue.append(item)  # 枚举所有可能出现的二项 即同时出现的二项
                for i in range(len(freq1)):
                    for j in range(len(freq1)):
                        if j != i:
                            item = freq1[i] + '->' + freq1[j]
                            queue.append(item)  # 第一次遍历后全部可能出现的情况 # 枚举非同时，含有时序信息的二项
                for i in range(len(queue)):
                    freq_item = self.isFreq(queue[i], data)
                    if freq_item != 0:
                        queue_new.append(freq_item)
                queue = []  # 清空queue(备选序列)
            if (queue_new != []):  # 后几次遍历时要把所有的情况写入空的queue中
                if top == len(queue_new) - 1:  # 表示没有新加入元素，那么终止 while 循环
                    print('频繁多项集为:%s' % queue_new)
                    break
                else:
                    demo_list = []  # 专门放'AB','BF','AF'这样的频繁序列，后面将他们合成为更多成员的备选频繁序列
                    for i in range(top, len(queue_new)):
                        if '->' not in queue_new[i]:
                            demo_list.append(queue_new[i])
                    demo_string = self.List_to_String(
                        demo_list)  # 将列表中的元素拼接成字符串，诸如拼成'ABBFAF'
                    demo_ele = "".join(set(demo_string))  # 删除串中的重复元素,输出'ABF'
                    if len(demo_ele) >= times:
                        if len(demo_ele) == times:  # 那么demo_ele是唯一的备选成员
                            queue.append(demo_ele)
                            times += 1
                        # 否则对备选字母进行排列组合，比如'ABCDE'，一共能排列出10钟情况，并把它们推入queue(待判断成员队列)
                        else:
                            combin = self.Combinations(demo_ele, times)
                            for i in range(len(combin)):
                                queue.append(combin[i])
                            times += 1
                    ###-----####至此已经把备选频繁寻列推入 queue ####-----###
                    queue = self.Make_time_queue(top, freq1, queue, queue_new)
                    ###-----#### 至此已经把 queue 放满了备选成员 ####-----###
                    top = len(queue_new)  # 更新队尾指针 top 的位置
                    # 候选剪枝
                    ###-----#### 检测 queue 中的备选序列是否频繁 ####-----###
                    for i in range(len(queue)):
                        freq_item = self.isFreq( 
                            queue[i], data)  # ---->> isFreq
                        if freq_item != 0:  # 如果这个成员是频繁的
                            queue_new.append(freq_item)
                    queue = []
    # 将列表中的字母合并成字符串   # 这个函数可以省略
    def List_to_String(self, list):
        demo_string = ''
        for i in range(len(list)):
            demo_string = demo_string + list[i]
        return demo_string
    #demo_ele是待排列的字符串, times是将它们排列成几个元素
    def Combinations(self, item, times):
        demo_list = []
        combin = []
        element = ''
        for i in range(1, len(item) + 1):
            iter = itertools.combinations(item, i)
            demo_list.append(list(iter))
        demo_combin = demo_list[times - 1]
        for i in range(len(demo_combin)):
            for j in range(len(demo_combin[0])):
                element += demo_combin[i][j]
            combin.append(element)
            element = ''
        return combin
    # 判断 item 是否在 data[i][j]中
    def isIn_Item(self, item, data, i, j):
        demo_num = 0
        for k in range(len(item)):
            if item[k] in data[i][j]:
                demo_num += 1
        if demo_num == len(item):
            return 1
        else:
            return 0
    def isFreq(self, item, data):
        # 支持度计算 
        num = 0
        if '->' not in item:  # 类似如'ABF'
            for i in range(len(data)):
                for j in range(len(data[i])):
                    if self.isIn_Item(item, data, i, j) != 0:
                        num += 1
            if num >= 2:
                return item
            else:
                return 0
        else:  # 类似如‘D->B->A’
            item0 = item.split('->')   # 将item分割成一个list
            for i in range(len(data)):
                array = 0
                j = 0
                while True:
                    if array == len(item0) or j == len(data[i]):
                        break
                    if len(item0[array]) >= 2:  # 如果类似 'BA' 形式
                        if self.isIn_Item(item0[array], data, i, j) == 1: 
                            array += 1
                            j += 1
                        else:
                            j += 1
                    else:
                        if item0[array] in data[i][j]:
                            array += 1
                            j += 1
                        else:
                            j += 1
                if array == len(item0):
                    num += 1
            if num >= 2:
                return item
            else:
                return 0
        
    
    ##############Begin####################
    # 挖掘带窗口大小约束的序列模式-改进的支持度计算        
    def Make_time_queue(self, top, freq1, queue, queue_new):
        for i in range(top, len(queue_new)):
            #           for j in range(len(freq1)):
            if '->' not in queue_new[i]:
                difference = self.Difference(queue_new[i], freq1)
                for j in range(len(difference)):
                    queue.append(difference[j] + '->' +
                                 queue_new[i])  # 诸如 'D->AB'
                    queue.append(queue_new[i] + '->' +
                                 difference[j])  # 诸如 'AB->D'
            else:
                difference = self.Difference(queue_new[i], freq1)
                for j in range(len(difference)):
                    # 诸如'B->A' 扩展成 'B->A->D'
                    queue.append(queue_new[i] + '->' + difference[j])
        return queue
    ##############Begin####################

第五关

import itertools
import datetime
 
class Base(object):
    def __init__(self):
        self.queue = []
    def freq1(self, data, frequent_num):
        appear = ''
        freq1 = []
        appear_ele = []
        appear_ele2 = []
        for i in range(len(data)):
            appear = ''
            for j in range(len(data[i])):
                appear += data[i][j]
            appear_ele += list(set(appear))
            print(appear_ele)
        #print(appear_ele)
        appear_ele2 = list(set(appear_ele))
        print(appear_ele2)
        for item in appear_ele2:
            itmes = appear_ele.count(item)
            if itmes >= frequent_num:
                freq1.append(item)
        print('频繁1项集为:%s' % freq1)
        return freq1
    def freq_more(self, data, freq1):
        # 候选生成
        queue = []  # 所有的备选序列放在这里面
        queue_new = []  # 最终结果在这里面
        top = 0  # 这个是queue_new的队尾标号
        times = 3
        while True:
            if (queue_new == []):  # 为空则代表这是第一次遍历,python中的&&是and,||是or
                for i in range(len(freq1)):
                    for j in range(i + 1, len(freq1)):
                        item = freq1[i] + freq1[j]
                        queue.append(item)  # 枚举所有可能出现的二项 即同时出现的二项
                for i in range(len(freq1)):
                    for j in range(len(freq1)):
                        if j != i:
                            item = freq1[i] + '->' + freq1[j]
                            queue.append(item)  # 第一次遍历后全部可能出现的情况 # 枚举非同时，含有时序信息的二项
                for i in range(len(queue)):
                    freq_item = self.isFreq(queue[i], data)
                    if freq_item != 0:
                        queue_new.append(freq_item)
                queue = []  # 清空queue(备选序列)
            if (queue_new != []):  # 后几次遍历时要把所有的情况写入空的queue中
                if top == len(queue_new) - 1:  # 表示没有新加入元素，那么终止 while 循环
                    print('频繁多项集为:%s' % queue_new)
                    break
                else:
                    demo_list = []  # 专门放'AB','BF','AF'这样的频繁序列，后面将他们合成为更多成员的备选频繁序列
                    for i in range(top, len(queue_new)):
                        if '->' not in queue_new[i]:
                            demo_list.append(queue_new[i])
                    demo_string = self.List_to_String(
                        demo_list)  # 将列表中的元素拼接成字符串，诸如拼成'ABBFAF'
                    demo_ele = "".join(set(demo_string))  # 删除串中的重复元素,输出'ABF'
                    if len(demo_ele) >= times:
                        if len(demo_ele) == times:  # 那么demo_ele是唯一的备选成员
                            queue.append(demo_ele)
                            times += 1
                        # 否则对备选字母进行排列组合，比如'ABCDE'，一共能排列出10钟情况，并把它们推入queue(待判断成员队列)
                        else:
                            combin = self.Combinations(demo_ele, times)
                            for i in range(len(combin)):
                                queue.append(combin[i])
                            times += 1
                    ###-----####至此已经把备选频繁寻列推入 queue ####-----###
                    queue = self.Make_time_queue(top, freq1, queue, queue_new)
                    ###-----#### 至此已经把 queue 放满了备选成员 ####-----###
                    top = len(queue_new)  # 更新队尾指针 top 的位置
                    # 候选剪枝
                    ###-----#### 检测 queue 中的备选序列是否频繁 ####-----###
                    for i in range(len(queue)):
                        freq_item = self.isFreq( 
                            queue[i], data)  # ---->> isFreq
                        if freq_item != 0:  # 如果这个成员是频繁的
                            queue_new.append(freq_item)
                    queue = []
    # 将列表中的字母合并成字符串   # 这个函数可以省略
    def List_to_String(self, list):
        demo_string = ''
        for i in range(len(list)):
            demo_string = demo_string + list[i]
        return demo_string
    #demo_ele是待排列的字符串, times是将它们排列成几个元素
    def Combinations(self, item, times):
        demo_list = []
        combin = []
        element = ''
        for i in range(1, len(item) + 1):
            iter = itertools.combinations(item, i)
            demo_list.append(list(iter))
        demo_combin = demo_list[times - 1]
        for i in range(len(demo_combin)):
            for j in range(len(demo_combin[0])):
                element += demo_combin[i][j]
            combin.append(element)
            element = ''
        return combin
    # 判断 item 是否在 data[i][j]中
    def isIn_Item(self, item, data, i, j):
        demo_num = 0
        for k in range(len(item)):
            if item[k] in data[i][j]:
                demo_num += 1
        if demo_num == len(item):
            return 1
        else:
            return 0
    def isFreq(self, item, data):
        # 支持度计算 
        num = 0
        if '->' not in item:  # 类似如'ABF'
            for i in range(len(data)):
                for j in range(len(data[i])):
                    if self.isIn_Item(item, data, i, j) != 0:
                        num += 1
            if num >= 2:
                return item
            else:
                return 0
        else:  # 类似如‘D->B->A’
            item0 = item.split('->')   # 将item分割成一个list
            for i in range(len(data)):
                array = 0
                j = 0
                while True:
                    if array == len(item0) or j == len(data[i]):
                        break
                    if len(item0[array]) >= 2:  # 如果类似 'BA' 形式
                        if self.isIn_Item(item0[array], data, i, j) == 1: 
                            array += 1
                            j += 1
                        else:
                            j += 1
                    else:
                        if item0[array] in data[i][j]:
                            array += 1
                            j += 1
                        else:
                            j += 1
                if array == len(item0):
                    num += 1
            if num >= 2:
                return item
            else:
                return 0
    # 创造新的备选时间序列
    def Make_time_queue(self, top, freq1, queue, queue_new):
        for i in range(top, len(queue_new)):
            #           for j in range(len(freq1)):
            if '->' not in queue_new[i]:
                difference = self.Difference(queue_new[i], freq1)
                for j in range(len(difference)):
                    queue.append(difference[j] + '->' +
                                 queue_new[i])  # 诸如 'D->AB'
                    queue.append(queue_new[i] + '->' +
                                 difference[j])  # 诸如 'AB->D'
            else:
                difference = self.Difference(queue_new[i], freq1)
                for j in range(len(difference)):
                    # 诸如'B->A' 扩展成 'B->A->D'
                    queue.append(queue_new[i] + '->' + difference[j])
        return queue 
        
    ################Begin###############
    # 挖掘带最大跨度约束的序列模式-后处理
    def isIn_Time(self, item0, data, i, j):
        num = 0
        item0_lenth = len(item0)
        if item0_lenth == 2:
            for m in range(j + 1, len(data[i])):
                if item0[1] in data[i][m]:
                    num += 1
        else:
            if item0[item0_lenth - 2] in data[i][j]:
                for m in range(j + 1, len(data[i])):
                    if item0[item0_lenth - 1] in data[i][m]:
                        num += 1
                        break
        return num
    ################Begin###############

第六关

import itertools
import datetime
 
class Base(object):
    def __init__(self):
        self.queue = []
    def freq1(self, data, frequent_num):
        appear = ''
        freq1 = []
        appear_ele = []
        appear_ele2 = []
        for i in range(len(data)):
            appear = ''
            for j in range(len(data[i])):
                appear += data[i][j]
            appear_ele += list(set(appear))
            print(appear_ele)
        #print(appear_ele)
        appear_ele2 = list(set(appear_ele))
        print(appear_ele2)
        for item in appear_ele2:
            itmes = appear_ele.count(item)
            if itmes >= frequent_num:
                freq1.append(item)
        print('频繁1项集为:%s' % freq1)
        return freq1
    def freq_more(self, data, freq1):
        # 候选生成
        queue = []  # 所有的备选序列放在这里面
        queue_new = []  # 最终结果在这里面
        top = 0  # 这个是queue_new的队尾标号
        times = 3
        while True:
            if (queue_new == []):  # 为空则代表这是第一次遍历,python中的&&是and,||是or
                for i in range(len(freq1)):
                    for j in range(i + 1, len(freq1)):
                        item = freq1[i] + freq1[j]
                        queue.append(item)  # 枚举所有可能出现的二项 即同时出现的二项
                for i in range(len(freq1)):
                    for j in range(len(freq1)):
                        if j != i:
                            item = freq1[i] + '->' + freq1[j]
                            queue.append(item)  # 第一次遍历后全部可能出现的情况 # 枚举非同时，含有时序信息的二项
                for i in range(len(queue)):
                    freq_item = self.isFreq(queue[i], data)
                    if freq_item != 0:
                        queue_new.append(freq_item)
                queue = []  # 清空queue(备选序列)
            if (queue_new != []):  # 后几次遍历时要把所有的情况写入空的queue中
                if top == len(queue_new) - 1:  # 表示没有新加入元素，那么终止 while 循环
                    print('频繁多项集为:%s' % queue_new)
                    break
                else:
                    demo_list = []  # 专门放'AB','BF','AF'这样的频繁序列，后面将他们合成为更多成员的备选频繁序列
                    for i in range(top, len(queue_new)):
                        if '->' not in queue_new[i]:
                            demo_list.append(queue_new[i])
                    demo_string = self.List_to_String(
                        demo_list)  # 将列表中的元素拼接成字符串，诸如拼成'ABBFAF'
                    demo_ele = "".join(set(demo_string))  # 删除串中的重复元素,输出'ABF'
                    if len(demo_ele) >= times:
                        if len(demo_ele) == times:  # 那么demo_ele是唯一的备选成员
                            queue.append(demo_ele)
                            times += 1
                        # 否则对备选字母进行排列组合，比如'ABCDE'，一共能排列出10钟情况，并把它们推入queue(待判断成员队列)
                        else:
                            combin = self.Combinations(demo_ele, times)
                            for i in range(len(combin)):
                                queue.append(combin[i])
                            times += 1
                    ###-----####至此已经把备选频繁寻列推入 queue ####-----###
                    queue = self.Make_time_queue(top, freq1, queue, queue_new)
                    ###-----#### 至此已经把 queue 放满了备选成员 ####-----###
                    top = len(queue_new)  # 更新队尾指针 top 的位置
                    # 候选剪枝
                    ###-----#### 检测 queue 中的备选序列是否频繁 ####-----###
                    for i in range(len(queue)):
                        freq_item = self.isFreq( 
                            queue[i], data)  # ---->> isFreq
                        if freq_item != 0:  # 如果这个成员是频繁的
                            queue_new.append(freq_item)
                    queue = []
    # 将列表中的字母合并成字符串   # 这个函数可以省略
    def List_to_String(self, list):
        demo_string = ''
        for i in range(len(list)):
            demo_string = demo_string + list[i]
        return demo_string
    #demo_ele是待排列的字符串, times是将它们排列成几个元素
    def Combinations(self, item, times):
        demo_list = []
        combin = []
        element = ''
        for i in range(1, len(item) + 1):
            iter = itertools.combinations(item, i)
            demo_list.append(list(iter))
        demo_combin = demo_list[times - 1]
        for i in range(len(demo_combin)):
            for j in range(len(demo_combin[0])):
                element += demo_combin[i][j]
            combin.append(element)
            element = ''
        return combin
    # 判断 item 是否在 data[i][j]中
    def isIn_Item(self, item, data, i, j):
        demo_num = 0
        for k in range(len(item)):
            if item[k] in data[i][j]:
                demo_num += 1
        if demo_num == len(item):
            return 1
        else:
            return 0
    def isFreq(self, item, data):
        # 支持度计算 
        num = 0
        if '->' not in item:  # 类似如'ABF'
            for i in range(len(data)):
                for j in range(len(data[i])):
                    if self.isIn_Item(item, data, i, j) != 0:
                        num += 1
            if num >= 2:
                return item
            else:
                return 0
        else:  # 类似如‘D->B->A’
            item0 = item.split('->')   # 将item分割成一个list
            for i in range(len(data)):
                array = 0
                j = 0
                while True:
                    if array == len(item0) or j == len(data[i]):
                        break
                    if len(item0[array]) >= 2:  # 如果类似 'BA' 形式
                        if self.isIn_Item(item0[array], data, i, j) == 1: 
                            array += 1
                            j += 1
                        else:
                            j += 1
                    else:
                        if item0[array] in data[i][j]:
                            array += 1
                            j += 1
                        else:
                            j += 1
                if array == len(item0):
                    num += 1
            if num >= 2:
                return item
            else:
                return 0
    # 创造新的备选时间序列
    def Make_time_queue(self, top, freq1, queue, queue_new):
        for i in range(top, len(queue_new)):
            #           for j in range(len(freq1)):
            if '->' not in queue_new[i]:
                difference = self.Difference(queue_new[i], freq1)
                for j in range(len(difference)):
                    queue.append(difference[j] + '->' +
                                 queue_new[i])  # 诸如 'D->AB'
                    queue.append(queue_new[i] + '->' +
                                 difference[j])  # 诸如 'AB->D'
            else:
                difference = self.Difference(queue_new[i], freq1)
                for j in range(len(difference)):
                    # 诸如'B->A' 扩展成 'B->A->D'
                    queue.append(queue_new[i] + '->' + difference[j])
        return queue 
        
    # 挖掘带最大跨度约束的序列模式
    def isIn_Time(self, item0, data, i, j):
        num = 0
        item0_lenth = len(item0)
        if item0_lenth == 2:
            for m in range(j + 1, len(data[i])):
                if item0[1] in data[i][m]:
                    num += 1
        else:
            if item0[item0_lenth - 2] in data[i][j]:
                for m in range(j + 1, len(data[i])):
                    if item0[item0_lenth - 1] in data[i][m]:
                        num += 1
                        break
        return num
    ################Begin###############
    # 如何挖掘带最大间隔约束的序列模式-改进的剪枝方法              
    # 寻找两个字符串中的不同字母，并提取出来
    def Difference(self, item, freq1):
        demo_list = []
        if '->' not in item:
            for i in range(len(freq1)):
                if freq1[i] not in item:
                    demo_list.append(freq1[i])
        else:
            demo_item = item.split('->')  # 将诸如'A->B'拆分成 'A','B'
            demo_item_string = self.List_to_String(demo_item)  # 合并成'AB'
            for i in range(len(freq1)):
                if freq1[i] not in demo_item_string:
                    demo_list.append(freq1[i])
        return demo_list
        ################End###############
峰峰688
关注
GSP序列模式分析算法
走在前往架构师的路上
02-10 1万+
参考资料：http://blog.csdn.net/zone_programming/article/details/42032309 更多数据挖掘代码：https://github.com/linyiqun/DataMiningAlgorithm 介绍 GSP算法是序列模式挖掘算法的一种，他是一种类Apriori的一种，整个过程与Apriori算法比较类似，不过在细节上会略有不同，在下
数据挖掘进阶之序列模式分析算法GSP的实现_gsp算法进行序列模式挖掘
最新发布
2401_84411433的博客
05-03 891
我可以将最近整理的前端面试题分享出来，其中包含HTML、CSS、JavaScript、服务端与网络、Vue、浏览器、数据结构与算法等等，还在持续整理更新中，希望大家都能找到心仪的工作。开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】
python--数据挖掘中GSP算法
懒and惰博客
04-19 3528
一、DSP算法与Apriori的不同 GSP算方法跟Apriori算法很类似 唯一的不同就是频繁项的选择 Apriori算法：https://blog.csdn.net/qq_43372138/article/details/89279586 Apriori算法频繁项集的选择是无序的 例如： A=（a,b）,B=（b,a） A,B是两个频繁项集 在Apriori中，A,B是同一个频繁项集 在DSP...
GSP算法及源代码.pdf
08-23
GSP算法及源代码，收藏绝对的经典！！！！
Python中的 GSP（广义序列模式）算法_python_代码_下载
06-08
python 数据挖掘 模式识别 数据挖掘算法 普惠制 用法 配置和运行示例位于测试文件夹gsppy 文件夹中。 要在项目中使用它，请将其导入并使用 GSP 类。
GSP（Generalized Sequential Pattern Mining）算法
很吵请安静
07-18 4279
Generalized Sequential Pattern (GSP) Mining 数据预处理 根据Id将item 根据时间排序 得到如下的序列，一个项集里面如果有多个项，说明这个项集里面项s是属于同一个时间点的，内部不分先后顺序，一般按照字典序排列。 GSP算法 找出频繁一项集 找出所有满足支持度的频繁一项集，支持度的计算是按照用户粒度的，比如一个用户ID下A出现了三次，那么A的计数只会...
gsp.rar_GSP_aprioriall_gsp算法
09-21
本文将详细讲解GSP算法，它是AprioriAll算法的一种扩展，旨在提高Apriori类算法的效率。 **Apriori算法** Apriori算法的基本思想是：如果一个项集是频繁的，那么它的所有子集也必须是频繁的。它通过迭代的方式生成...
数据挖掘之序列模式挖掘之GSP算法
11-16
GSP算法由Ganesh Ramakrishnan、Michael J. Franklin和S. M. T. Ali Emrouznejad在2000年提出，旨在解决传统的Apriori-based算法在处理大规模序列数据库时的效率问题。Apriori算法虽然在频繁项集挖掘中表现出色，但...
GSP.rar_GSP_Gsp-Algorithm_gsp算法_prefixspan_数据挖掘GSP
09-24
本资源“GSP.rar”包含GSP算法的相关实现，可以帮助开发者理解和应用这一算法。 GSP算法，全称为Growth-Share-Path，是由Yan et al.在2002年提出的，它是PrefixSpan算法的一种优化版本。PrefixSpan是一种高效的前缀...
GSP.rar_GSP_gsp c++_gsp算法_算法的C++实现
09-14
在C++中实现GSP算法，首先需要理解算法的基本步骤： 1. **初始化**：创建一个初始解，通常是随机生成的。例如，在旅行商问题中，可以随机排列城市的顺序作为路径。 2. **局部搜索**：执行局部改进操作，通过交换解中...
序列模式GSP算法
01-05
关于序列模式算法的简单介绍及GSP算法的实现步骤，实例讲解，GSP的缺陷
ga求解gsp问题_遗传算法；旅行商问题；matlab_
10-02
遗传算法（GA）求解旅行商问题（TSP）可直接运行
数据挖掘-序列模式挖掘--GSP算法
数据挖掘+大数据研发+算法学习
05-03 4812
一：基本概念介绍 序列模式挖掘：指挖掘相对时间或其他模式出现频率高的模式 序列模式挖掘的动机：大型连锁超市的交易数据有一系列的用户事物数据库。每一条记录包括用户的ID，事物发生的时间和事物涉及的项目。如果能够在其中挖掘涉及事物间关联关系的模式，即用户几次购买行为间的联系，可以采用更有针对性的营销措施。 序列：(sequence) 以SID表示，一个序列即是一个完整的信息流 序列符号化表示：...
GSP序列模式算法
m0_37786726的博客
04-10 1587
参考文献：https://wenku.baidu.com/view/a28e951eb9d528ea80c7795a.html                 https://blog.csdn.net/androidlushangderen/article/details/43699083GSP:GSP算法是序列模式挖掘算法的一种，他是一种类Apriori的一种，整个过程与Apriori算法比较...
序列模式挖掘——GSP算法实战
zxxxlh123的博客
11-16 2786
GSP算法实战 #统计组合出现次数 def cou_ls(LS):#LS为列表 dic={} for i in LS: dic[i]=dic.get(i,0)+1 return dic #删除支持度小于2的 def cut_m(item):#item为字典 for k in list(item.keys()): if item[k]<2: del item[k] return item imp
GSP算法 demo
leokingszx的博客
09-02 1184
对https://blog.csdn.net/qq_43372138/article/details/89405809里的代码稍微修改了一下，复制后即可直接运行 import re import pandas as pd from collections import defaultdict as de def dell(d, na): for i in na: d...
GSP算法在数据挖掘中的应用
weixin_56781779的博客
01-10 1198
序列模式挖掘：指挖掘相对时间或其他模式出现频率高的模式序列模式挖掘的动机：大型连锁超市的交易数据有一系列的用户事物数据库。每一条记录包括用户的ID，事物发生的时间和事物涉及的项目。如果能够在其中挖掘涉及事物间关联关系的模式，即用户几次购买行为间的联系，可以采用更有针对性的营销措施。序列：(sequence) 以SID表示，一个序列即是一个完整的信息流序列符号化表示：序列是不同项目集的有序排列。
GSP算法与SPADE算法
qq_22135585的博客
07-30 1368
转载：https://blog.csdn.net/u013007900/article/details/54890950#commentBox GSP算法 GSP算法是AprioriAll算法的扩展算法，其算法的执行过程和AprioriAll类似。 其核心思想是：在每一次扫描(pass)数据库时,利用上一次扫描时产生的大序列生成候选序列,并在扫描的同时计算它们的支持度(support),满足支...
GSP算法详解：概念、步骤与实例
"序列模式挖掘算法的理解与GSP算法详解" 序列模式挖掘是数据挖掘领域的一个重要分支，它主要用于发现时间上有先后顺序的数据中的模式。这些模式可以应用于多个领域，如预测客户购买行为、Web访问模式分析、疾病诊断...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

峰峰688

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值