数据挖掘的定义

从大量、未知的、不完全的、有噪声的、模糊的、随机的数据（包括文本）中挖掘出隐含的对决策有潜在价值的关系、模式和趋势，并用这些知识和规则建立用于决策支持的模型，提供预测性决策支持的方法、工具和过程，就是数据挖掘

数据挖掘的基本任务

数据挖掘的基本任务包括利用分类与预测、聚类分析、关联规则、时序模式、偏差检测、智能推荐等方法，

关联规则

关联模式挖掘旨在从大量的数据当中发现特征之间或数据之间的相互依赖关系。这种存在于给定数据集中的频繁出现的关联模式，又称为关联规则。

聚类分析

聚类分析是根据数据本身结构特征对数据点进行分类的方法。实质是按照彼此距离的远近将数据分为若干个类别，以使得类别内数据的“差异性”尽可能小(即“同质性”尽可能大)，类别间“差异性”尽可能大。

时间序列

基于事物发展的延续性和随机性预测事物未来的发展，如：销售量预测、天气预测等。

数据探索的基本工作(怎么样进行数据挖掘)

1. 定义挖掘目标
2. 数据取样
3. 数据探索
4. 数据预处理
5. 挖掘建模
6. 模型评价

数据预处理涵盖的三个内容

数据清洗，数据集成，数据规约

数据清洗：主要是删除原始数据集中的无关数据、重复数据，平滑噪声数据，处理缺失值、异常值等

数据集成：就是将多个数据源合并存放在一个一致的数据储存位置的过程

数据规约：产生更小且保持原数据完整性的新数据集，在归约后的数据集上进行分析和挖掘讲提高效率

掌握常见数据异常处理方法

1. 删除记录
2. 数据插补

数据插补的有：

1. 均值/中位数/众数插补
2. 使用固定值
3. 回归方法
4. 插值法：
   1. 拉格朗日插值法
   2. 牛顿插值法

1. 不处理

数据集成中实体识别的任务

数据挖掘需要的数据往往分布在不同的数据源中，数据集成就是将多个数据源合并存放在一个一致的数据存储（如数据仓库）中的过程。

在数据集成时，来自多个数据源的现实世界实体的表达形式是不一样的，不一定是匹配的，要考虑实体识别问题和属性冗余问题，从而把源数据在最低层上加以转换、提炼和集成

实体识别的任务是检测和解决同名异义、异名同义、单位不统一的冲突

描述数据变异程度的常用指标

反映总体各单位标志值的差异程度或离散程度指标

1、极差，=极大值-极小值，易受样本含量的影响，很不稳定。不宜在样本含量悬殊时使用

2、四分位数间距(Q)，适用于各种分布的变量

3、方差，适用于对称分布，特别是服从正态分布的变量

4、标准差，适用于对称分布，特别是服从正态分布的变量

5、变异系数，，常用于量纲(函数关系)不同或均数相差较大时变量间变异程度的比较

如何用Numpy来生成正态分布的随机数？

第一参数u是服从正态分布的随机变量的均值,第二个参数是σ此随机变量的方差,所以正态分布记作N(μ,σ)

np.random.normal(loc=0.0,scale=1.0,size=None)

loc:float此概率分布的均值(对应着整个分布的中心centre)

scale:float此概率分布的标准差

(对应于分布的宽度,scale越大越矮胖,scale越小,越瘦高)

size:int or tuple 可以用来构造多维的

输出的shape,默认为None,只输出一个值

np.random.standard_normal(size=None)

返回指定形状的标准正态分布的数组。

标准正态分布（均值为0，标准差为1）：

numpy.random.randn(d0, d1, ..., dn)

这里代码应用

# 如何用Numpy来生成正态分布的随机数？
import numpy
def NormalDistribution(size):
    randn = numpy.random.randn(size)
    standard_normal = numpy.random.standard_normal(size)
    # 生成均值為0，方差為1的正態分佈
    normal = numpy.random.normal(loc=0.0, scale=1.0, size=size)
    return randn, standard_normal, normal

if __name__ == '__main__':
    a, b, c = NormalDistribution(5)
    print(a)
    print(b)
    print(c)

数据预处理中属性构造的过程

在数据挖掘的过程中，为了帮助提取更有用的信息、挖掘更深层次的模式，提高挖掘结果的精度，需要利用已有的属性集构造出新的属性，并加入到现有的属性集合中

数据规范化的方法

数据标准化（归一化）处理是数据挖掘的一项基础工作，不同评价指标往往具有不同的量纲和量纲单位，数值间的差别可能很大，不进行处理可能会影响到数据分析的结果，为了消除指标之间的量纲和大小不一的影响，需要进行数据标准化处理，将数据按照比例进行缩放，使之落入一个特定的区域，从而进行综合分析。如将工资收入属性值映射到[-1，1]或者[0，1]之间。

下面介绍三种规范化方法：最小-最大规范化、零-均值规范化、小数定标规范化

import numpy

def normalizeFunction(array):
    # 極差 最大減最小
    # 最小 - 最大规范化：也称为离差标准化
    range = numpy.max(array) - numpy.min(array)
    newArray = (array - numpy.min(array)) / range
    # 零 - 均值规范化: 也叫标准差标准化
    mean = numpy.mean(array)
    standard_deviation = numpy.std(array)
    newArrayTwo = (array - mean) / standard_deviation
    # 小数定标规范化: 通过移动属性值的小数位数，将属性值映射到[-1，1]之间，移动的小数位数取决于属性值绝对值的最大值
    k = 100  # 最高位
    newArrayThree = array / k
    return newArray, newArrayTwo, newArrayThree

if __name__ == '__main__':
    # 如果確定的隨機種子那麼隨機出來都是一樣的
    numpy.random.seed(100)
    randn = numpy.random.randint(0, 100, size=10)
    print(randn)
    a, b, c = normalizeFunction(randn)
    print(a)
    print(b)
    print(c)

数据挖掘中分类和聚类的任务各是什么？

分类和预测是预测问题的两种主要类型。

分类主要是预测分类标号（离散、无序的）

预测主要是建立连续值函数模型，预测给定自变量的条件下因变量的值

决策树算法（ID3和C4.5）

ID3算法

其核心是在决策树的各级节点上，使用信息增益方法作为属性的选择标准，来帮助确定生成每个节点时所应采用的合适属性。

C4.5

C4.5决策树生成算法相对于ID3算法的重要改进是使用信息增益率来选择节点属性。C4.5算法可以克服ID3算法存在的不足：ID3算法只适用于离散的描述属性，而C4.5算法既能够

处理离散的描述属性，也可以处理连续的描述属性。

1：数据集种类(目标变量)越多越复杂熵越大，所以原始数据的熵最大

2：熵公式：  

 n代表X的n种不同的离散取值，pi代表X取值为i的概率，log以2或e为底的对数

3：信息增益(简单处理)：原始数据熵-目前特征的熵

回归分析（常见回归分析算法有哪些）

因为是选择题，里面复杂的不在仔细叙述（因为其中每一个拿出来都是一堆内容）

回归分析是确定预测属性（数值型）与其他变量间相互依赖的定量。

关系的最常用的统计学方法。

1. 线性回归
2. 非线性回归
3. Logistic回归（逻辑回归）这个是分类
4. 岭回归
5. 主成分回归
6. 偏最小二乘回归

预测问题的类型

（就是这个数据采用什么来进行预测）

离散值预测和连续值预测

有监督学习和无监督学习的概念

有监督学习

1. 有标签的数据
2. 直接有反馈
3. 预测结果/未来

无监督学习

1. 无标签/目标
2. 无反馈
3. 寻找数据中隐藏结构

贝叶斯分类

决策树分类

关联规则分析

应该是使用sklearn

这样就比较简单，如果是自己写这两个贝叶斯和决策树。难度太高了

这个是决策树

from sklearn.tree import DecisionTreeClassifier
tre=DecisionTreeClassifier()
tre.fit(x_train,y_train)
y_predict = dtc.predict(x_test)

这个是贝叶斯

from sklearn.naive_bayes import MultinomialNB
clf = MultinomialNB()
clf.fit(X, y)
y_predict = clf.predict(x_test)

都是直接调用API

我还是贴一下如果自己实现两中算法的代码

关联规则分析

关联规则分析是数据挖掘中最活跃的研究方法之一，目的是在一个数据集中找出各项之间的关联关系，而这种关系并没有在数据中直接表示出来。

但是如果每一个种类都算，太花费时间了

这里的apriori算法

Apriori原理是说如果某个项集是频繁的，那么它的所有子集也是频繁的。

同意的如果一个项集是非频繁的，那么它的所有超集都是非频繁的

这样是减少查找时间

简单的来说，就是如果有{0},{1},{2},{3}这些组成相集，就是所有的全排列

如果{0, 1}这个项集是频繁的，那么{0}和{1}也一定是频繁的。

假设{2, 3}这个项集是非频繁的，那么跟它有关的{0, 2, 3}，{1, 2, 3}，{0, 1, 2, 3}都是非频繁的。也就是说算完{2, 3}的支持度发现不是频繁的，那么后面3个项集的支持度就不需要算了，这样就减小了计算的时间复杂度。

这里Educoder上和书上的代码差不到多少

然后这里看一下过程

、

while 集合中的项的个数 > 0:  

    构建一个由 k 个项组成的候选项集的列表  

    确认每个项集都是频繁的  

保留频繁项集并构建 k+1 项组成的候选项集的列表  

每次都变大一点，然后先保证他是频繁的，然后变大一项

然后是找关联关系，看一下实验8

import numpy
import pandas as pd

data=[[1, 2, 5], [2, 4], [2, 3], [1, 2, 4], [1, 3], [2, 3],[1, 3], [1, 2, 3, 5], [1, 2, 3]]

def createC1(dataset):
    C1 = set()
    # set()函数创建一个无序不重复元素集
    # 遍历查找每一个单个元素,就比如｛｛1，4，6｝｛0，2｝｛1，3｝｛1，5，6｝｝中找出来{0},｛1｝，｛2｝，｛3｝，｛4｝，｛5｝，｛6｝
    for t in dataset:
        for item in t:
            item_set = frozenset([item])
            # frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
            C1.add(item_set)
    return C1

# 从候选K项集到频繁K项集（支持度计算）

def scanD(D, Ck, minSupport):
    ssCnt = {}
    for tid in D:   # 遍历数据集
        for can in Ck:  # 遍历候选项
            if can.issubset(tid):  # 判断候选项中是否含数据集的各项
                if not can in ssCnt:
                    ssCnt[can] = 1  # 不含设为1
                else:
                    ssCnt[can] += 1  # 有则计数加1
    numItems = float(len(D))  # 数据集大小
    retList = []  # L1初始化
    supportData = {}  # 记录候选项中各个数据的支持度
    for key in ssCnt:
        support = ssCnt[key] / numItems  # 计算支持度
        if support >= minSupport:
            retList.insert(0, key)  # 满足条件加入L1中
            supportData[key] = support
    return retList, supportData


#构建含有k个元素的频繁项集
#如输入为{0},{1},{2}会生成{0,1},{0, 2},{1,2}
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]
            if L1 == L2:
                retList.append(Lk[i] | Lk[j])
                # x & y  ## 求交集
                # x | y  ## 求并集
                # x - y  ## 求差集
    return retList


# 传入数据集，最小的支持率
def apriori(dataSet, minsupport):
    # 首先找出最开始的数据项级{0},｛1｝，｛2｝，｛3｝，｛4｝，｛5｝，｛6｝
    C1 = createC1(dataSet)
    D = list(map(set, dataSet))
    # 把只有一个项级的支持率算出来
    L1, supportData = scanD(D, C1, minsupport)
    L = [L1]
    # 设置关联数
    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

# 要找到关联规则，需要从一个频繁项集开始
# 把apriori算法中找到的频繁集，找到里面最小可信度
# 这里面就有一对一或一对多
# 有两种解法

# 生成集合的所有子集
def getSubset(fromList, toList):
    for i in range(len(fromList)):
        t = [fromList[i]]
        tt = frozenset(set(fromList) - set(t))
        if not tt in toList:
            toList.append(tt)
            tt = list(tt)
            if len(tt) > 1:
                getSubset(tt, toList)

def calcConf_one(freqSet, H, supportData, ruleList, minConf):
    for conseq in H:  #遍历H中的所有项集并计算它们的可信度值
        conf = supportData[freqSet] / supportData[freqSet - conseq]  # 可信度计算，结合支持度数据
        # 提升度lift计算lift = p(a & b) / p(a)*p(b)
        lift = supportData[freqSet] / (supportData[conseq] * supportData[freqSet - conseq])
        if conf >= minConf and lift > 1:
            # print(freqSet - conseq, '-->', conseq, '支持度', round(supportData[freqSet], 6), '置信度：', round(conf, 6),'lift值为：', round(lift, 6))
            ruleList.append((freqSet - conseq, conseq, conf))

def gen_rule_one(L, supportData, minConf):
    bigRuleList = []
    for i in range(1, len(L)):  # 从二项集开始计算
        for freqSet in L[i]:  # freqSet为所有的k项集
            # 求该三项集的所有非空子集，1项集，2项集，直到k-1项集，用H1表示，为list类型,里面为frozenset类型，
            H1 = list(freqSet)
            all_subset = []
            getSubset(H1, all_subset)  # 生成所有的子集
            calcConf_one(freqSet, all_subset, supportData, bigRuleList, minConf)
    return bigRuleList

def calcConf(freqSet, H, supportData, brl, minConf = 0.7):
    prunedH = []
    for conseq in H:
        conf = supportData[freqSet]/supportData[freqSet - conseq]
    if conf >= minConf and conf!=1:
        brl.append((freqSet - conseq, conseq, conf))
        prunedH.append(conseq)
    return prunedH

def rulesFromConseq(freqSet, H, supportData, brl, minConf = 0.7):
    m = len(H[0])
    if len(freqSet) > m+1:
        Hmp1 = aprioriGen(H, m+1)
        Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)
        if len(Hmp1) > 1:
            rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)

def generateRules(dataset, minsupport, minConf):
    L, supportData = apriori(dataset, minsupport)
    bigRuleList = []
    for i in range(1, len(L)):
        for freqSet in L[i]:
            H1 = [] #对每个频繁项集构了,建只包含单个元素的集合,即可以出现在规则右边
            for item in freqSet:
                H1.append(frozenset([item]))
            if (i > 1):
                # 这里用了一个递归来找关联集
                H1 = calcConf(freqSet,H1,supportData,bigRuleList,minConf)
                #包含三个及以上元素的频繁集
                rulesFromConseq(freqSet,H1,supportData,bigRuleList,minConf)
            else:
                #包含两个元素的频繁集
                calcConf(freqSet,H1,supportData,bigRuleList,minConf)
    return bigRuleList

# 最后就是前后，数据输入和输出
# 首先是csv,exl文件的读入和读出

def read_file(filepath,one,two):
    # 读取路径
    data = pd.read_csv(filepath)
    dataSet =pd.read_excel(filepath)
    #对某一列进行排序(保证是顺序就行)
    data = data.sort_values(axis=0, by=one, ascending=True)
    #如果有字典操作 dic.get()操作
    # 根据one对two列合并，并使用“，”将各商品隔开
    data[two] = data[two].apply(lambda x: ',' + x)
    data = data.groupby(one).sum().reset_index()
    # 对合并的two列转换数据格式
    data[two] = data[two].apply(lambda x: [x[1:]])
    data_list = list(data[two])
    # 分割商品名为每个元素
    data_translation = []
    for i in data_list:
        p = i[0].split(',')
        # 如果有字典转换表，就把p提出来转换后加进去
        # a = []
        # for j in p:
        #     a.append(dic.get(j))
        # data_translation.append(a)
        data_translation.append(p)
    return  data_translation


if __name__ == '__main__':
    # 第一步拿到data_translation
    a=read_file()
    #第二步 apriori算法
    #第三步 生成规则