商品关联性分析python算法

# -*- coding: utf-8 -*-
“““
Created on Mon Apr 16 09:55:00 2018

@author: wzh
“““
#导入需要的模块

import pandas as pd
import numpy as np

#函数定义

def createC1（dataSet）:
    “““利用原始数据生成1项集（包含一个元素的子集）
    dataSet为我们需要输入的原始数据“““
    C0=[]
    for transaction in dataSet:
        for item in transaction: 
            if not [item] in C0:
                C0.append（[item]）
    
    C0.sort（）
    C1 = list（map（frozensetC0）） #将C1.list每个元素转换为hashable的frozenset
    return C1

def scanD（DckminSupport）:
    “““扫描之前得到的k项集（包含k个元素的子集），输出支持度大于最小支持度的频繁k项集（最小支持度用来控制最后输出的总数据量）和频繁k项集的支持度
    D为我们的原始数据，ck为之前得到的k项集，minSupport为我们希望用来控制数据量的最小支持度“““
    ssCnt={} #新建字典存储k项集和每个k项集出现的频率
    for tid in D:
        for can in ck:
            if can.issubset（tid）:
                if can in ssCnt:
                    ssCnt[can] += 1
                else: 
                    ssCnt[can] = 1
    
    numItem=float（len（D））
    retList=[]
    supportData={} #计算k项集的支持度，判断是否大于最小支持度
    for key in ssCnt:
        support=ssCnt[key]/numItem
        if support>=minSupport:
            retList.insert（0key）
            supportData[key]=support
            
    return retListsupportData#返回频繁k项集，相应支持度

def aprioriGen（Lkk）:
    “““利用递推的方法，利用k-1项集的并集来生成k项集
    Lk为我们输入的k-1项集“““
    retList=[]
    lenLk=len（Lk）
    for i in range（lenLk）:
        for j in range（i+1lenLk）:
            L1=list（Lk[i]）[:k-2]
            L2=list（Lk[j]）[:k-2]
            L1.sort（）
            L2.sort（）#排序
            if L1==L2:#比较ij前k-1个项若相同，和合并它俩
                retList.append（Lk[i] | Lk[j]）#加入新的k项集 
    return retList

def apriori（dataSetminSupport）:
    “““Apriori算法的主要逻辑函数，利用递推生成我们需要的所有频繁项集，并计算其支持度
    dataSet为原始数据，minSupport为最小支持度“““
    C1=createC1（dataSet）
    D=list（map（setdataSet））
    L1supportData=scanD（DC1minSupport）#利用k项集生成频繁k项集（即满足最小支持率的k项集）
    L=[L1]#L保存所有频繁项集
    
    k=2
    while（len（L[k-2]）>0）:#直到频繁k-1项集为空
        Ck=aprioriGen（L[k-2]k）#利用频繁k-1项集 生成k项集
        LksupK= scanD（DCkminSupport） #从k项集中筛选出频繁k项集
        supportData.update（supK）#保存新的频繁项集与其支持度
        L.append（Lk）#保存频繁k项集
        k+=1
    return LsupportData#返回所有频繁项集，与其相应的支持度

def calcConf（freqSetHsupportDatabrlminConf=0.1）:
    “““计算并输出我们需要的各个项集的关联关系，即置信度
    freqSet为我们要处理的单个频繁集，H为可以用来修建freqSet的所有子集构成的列表
    supportData为之前得到的存储频繁项集和相应支持度的字典，brl为已有的规则集
    minConf为控制输出数据量的最小支持度，我们这里将其定为0.1“““
    prunedH=[]
    for conseq in H:#后件中的每个元素
        conf=supportData[freqSet]/supportData[freqSet-conseq]
        if conf>=minConf:
            print （freqSet-conseq‘-->‘conseq‘conf:‘conf）
            brl.append（（freqSet-conseqconseqconf））#添加入规则集中
            prunedH.append（conseq）#添加入被修剪过的H中
    return prunedH # 返回修建后的子集列表

def rulesFromConseq（freqSetHsupportDatabrlminConf=0.1）: 
    “““递归逻辑函数，对于我们所有的频繁集，计算其和其修剪后的子集之间的置信度
    freqSet为我们要处理的单个频繁集，H为可以用来修建freqSet的所有子集构成的列表