聚类做预处理，基于关联规则推荐算法

使用聚类对movielens 1M数据集做预处理，在itemCF基础上改进的基于关联规则学习的推荐算法

# -*- coding: UTF-8 -*-
#__author__ = ‘fourier‘

import pandas as pd

def mergeData（data）:
    dataframe = pd.Dataframe（data）
    user_num = len（set（dataframe[0]））
    # print（user_num）
    mergedatas = []
    for i in range（user_num+1）:     #从0->51，但是不包括51，一共51个
        mergedatas.append（[]）
    for j in range（len（data））:
        for n in range（1user_num+11）:     #用来判断的用户id，从1->51，但不包括51
            if data[j][0] == n:
                mergedatas[n].append（data[j][1]）
    return mergedatas




# def loadDataSet（）:
#     return [[1 3 4] [2 3 5] [1 2 3 5][2 5]]

def createC1（dataSet）:
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if not [item] in C1:
                C1.append（[item]）
    C1.sort（）
    # return list（map（listlist（map（frozenset C1））））
    return list（map（frozensetC1））

#计算满足最小支持度的频繁多项集
def scanD（D Ck minSupport）:           #（数据集，候选一项集，最小支持度）
    ssCnt = {}
    for tid in D:
        for can in Ck:
            if can.issubset（tid）:
                # if not ssCnt.has_key（can）: ssCnt[can] = 1
                if can not in ssCnt:
                    ssCnt[can] = 1
                else: ssCnt[can] += 1
    numItems = float（len（D））
    retList = []              #满足最小支持度的物品
    supportData = {}            #支持度的值
    for key in ssCnt:
        support = ssCnt[key]/numItems
        if support >= minSupport:
            retList.insert（0key）
        supportData[key] = support
    return retList supportData       #满足最小支持度的物品，物品支持度的值

#返回由一项集组合而成的多项集
def aprioriGen（Lk k）:              #（频繁项集列表，项集内元素个数）
    retList = []
    lenLk = len（Lk）                 #用户个数
    for i in range（lenLk）:
        for j in range（i+1 lenLk）:
            L1 = list（Lk[i]）[:k-2]
            L2 = list（Lk[j]）[:k-2]
            L1.sort（）
            L2.sort（）
            if L1 == L2:
                retList.append（Lk[i] | Lk[j]）
    # print（retList）
    return retList          #返回由一项集组合而成的多项集

def apriori（dataSet minSupport）:
    C1 = createC1（dataSet）                   #一项集
    D = list（map（set dataSet））              #建集合set表示的数据集
    L1 supportData = scanD（D C1 minSupport）          #满足最小支持度的物品列表，物品的支持度的值
    L = [L1]            #L会包含L1 L2 L3、、、，现在包含了L1，通过while寻找L2L3、、、
    k = 2
    while（len（L[k-2]） > 0）:
        Ck = aprioriGen（L[k-2] k）              #得到频繁多项集
        Lk supK = scanD（D Ck minSupport）     #满足最小支持度的物品组合，物品组合的支持度的值
        supportData.update（supK）                #将一个字典的键值更新到另一个字典
        L.append（Lk）
        k += 1
    return L supportData

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----

     文件       3103  2018-05-08 11:30  recommendation_test\apriori_test.py

     文件       5578  2018-05-08 20:12  recommendation_test\itemCF_test.py

     文件       6102  2018-05-08 17:26  recommendation_test\item_CF.py

     文件       1954  2018-05-07 16:33  recommendation_test\kmeans_cluster_test.py

     文件    2438266  2018-05-01 17:18  recommendation_test\ratings.csv

     文件       3389  2018-05-08 20:17  recommendation_test\recommender_test.py

     文件       1892  2018-05-08 11:30  recommendation_test\__pycache__\apriori_test.cpython-36.pyc

     文件       2039  2018-05-08 17:34  recommendation_test\__pycache__\itemCF_test.cpython-36.pyc

     文件       1176  2018-05-07 17:31  recommendation_test\__pycache__\kmeans_cluster_test.cpython-36.pyc

     目录          0  2018-05-08 20:18  recommendation_test\__pycache__

     目录          0  2018-05-08 20:18  recommendation_test

----------- ---------  ---------- -----  ----

              2463499                    11