16066

最新推荐文章于 2023-07-18 16:04:29 发布

大大大太阳chen

最新推荐文章于 2023-07-18 16:04:29 发布

阅读量418

点赞数 1

文章标签：数据挖掘 python

本文链接：https://blog.csdn.net/weixin_51465502/article/details/129206648

版权

PTT知识点整理：
第一章：引论
1.十大经典的数据挖据算法：K-Means SVM Apriori EM PageRank AdaBoost KNN NaiveBayes CART C4.5
2.数据挖掘的发展动力:海量数据、社会需求
3.数据挖掘：从大量的、错综复杂的数据中挖掘哪些令人感兴趣的模式或知识；挖掘的不仅仅是数据
4.数据挖掘: 数据中的知识发现(KDD)步骤：1. 数据清理: (消除噪声和删除不一致的数据)60％的工作量；2. 数据集成（多种数据源可以组合在一起）；3. 数据选择；4. 数据变换；5. 数据挖掘；6. 模式评估；7. 知识表示
5.数据挖掘系统的特征：数据的特征、算法的特征、知识系统的特征
6.数据特征：大容量、含噪音、异质数据；算法特征：构成数据挖掘算法的三要素（模式记述语言、模式评价、模式探索）、主要方法（分类、聚类、相关规则、回归、其它）；知识系统特征：知识发现系统需要一个前处理过程、知识发现系统是一个自动/半自动过程、知识发现系统只能发现特定模式的知识
7.数据类型：数据库数据、数据仓库、事务数据、其他类型的数据
8.数据库系统：由一组内部相关的数据和一组管理和存取数据的软件程序组成关系数据库是表的汇集，每个表都被赋予一个唯一的名字
9.数据仓库（数据立方体）：是一个从多个数据源收集的信息存储库，存放在一致的模式下，并且通常驻留在单个站点上
10.空间数据库：地理信息系统(GIS)、遥感图像数据、医学图像数据
11.流数据是一组顺序、大量、快速、连续到达的数据序列，一般情况下数据流可被视为一个随时间延续而无限增长的动态数据集合
12.文本数据库存储的是对对象的文字性描述；文本数据库的分类（无结构类型、半结构类型、结构类型）；万维网(WWW)可以被看成最大的文本数据库
13.数据挖据的模式类型：描述性的数据挖掘、预测性的数据挖掘
14.数据特征化：对目标类数据的一般特性或特征的汇总；数据区分：将目标类数据对象的一般特征与一个或多个对比类的一般特征进行比较
15.频繁模式：在数据中频繁出现的模式，包括频繁项集、频繁子序列和频繁子结构
16.统计学：研究数据的收集、分析、解释和表示；统计模型：一组数学函数，他们用随机变量及其概率分布刻画目标类对象的行为
17.机器学习：是指考察计算机如何基于数据学习、其主要研究领域之一是，计算机程序基于数据自动的学习识别复杂的模式，并作出智能的决策
18.信息检索（IR）是搜索文档和文档中信息的科学
19.数据挖掘研究的主要问题成五组：挖掘方法、用户交互、有效性与可伸缩性、数据类型的多样性、数据挖掘与社会

第二章：认识数据

数据行对应数据对象, 列对应属性
2.属性是一个数据字段，表示数据对象的一个特征；类型：标称属性、二元属性、序数属性、数值属性（区间标度属性、比率标度属性）
3.标称属性：属性值是一些符号或者事物的名称；独热编码：使用N位状态寄存器来对N个状态进行编码，每个状态只有一位是1，其余都是零值
4.二元属性：是一种标称属性，只有两个状态：0或1；对称的: 两种状态具有同等价值，携带相同权重；非对称的: 其状态的结果不是同样重要，对重要的结果用1编码，另一个用0编码
5.序数属性：其可能的值之间具有有意义的序或者秩评定(ranking)，但是相继值之间的差是未知的
6.标称、二元和序数属性都是定性的，即只描述对象的特征，不给出实际的大小
7.数值属性:定量的且用具体数值表示；区间标度属性：使用相等的单位尺度度量，值有序，可以评估值之间的差，不能评估倍数，没有绝对的零点；比率标度属性：具有固定零点的数值属性，值有序，可以评估值之间的差，也可以说一个值是另一个的倍数
8.离散属性：具有有限或者无限可数个值，可以用或者不用整数表示；连续属性：属性值为实数，一般用浮点变量表示
9.中心趋势度量：均值、中位数、众数、中列数（最大数和最小数的平均值）；数据的散布：极差、四分位数极差、五数概括、盒图；数据可视化：分位数图、分位数-分位数图、直方图、散点图
10.describe()：给出样本的基本描述（基本统计量如均值、标准差等）
11.数据可视化意义：通过将数据映射在图元上来表示数据，便于深刻理解数据信息；便于对大型数据集进行定性描述；便于搜索数据间的模式，倾向，结构，不规则性，与联系性；为进一步的定量分析找到合适的区间与变量
12.分位数图：是一种观察单变量数据分布的简单有效方法
13.plot(折线图) pie(饼形图) hist(直方图) boxplot(箱型图) plot(logy=True)(绘制y轴的对数图形) plot(yerr=error)(绘制误差条形图)
14.邻近性:相似性和相异性都称为邻近性
15.qrst 对称的二元相异性:(r+s)/(q+r+s+t) 非对称的二元相异性:(r+s)/(q+r+s) Jaccard系数:q/(q+r+s) Note:q/(q+r)+(q+s)-q
16.闵可夫斯基距离 h=1曼哈顿距离,h=2欧几里德距离，h=无穷切比雪夫距离
17.距离需要满足的性质:非负性,对称性,三角不等式
18.标称属性的相似度:(p-m)/p，匹配属性值个数与总属性个数之比；二元属性的相似度： Jaccard系数；数值属性的相似度：明考夫斯基距离（事先对属性值进行归一化）；序数属性的相似度：将属性值利用[(次序值-1)/(属性值个数-1)]转为为实数；混合属性的相似度：依据各属性的特点组合

第三章：数据预处理
1.为什么数据预处理：现实世界中的数据是脏的：不完全（缺少属性值）、噪音（包含错误或孤立点）、不一致（编码或名字存在差异）
2.为什么数据预处理是重要的：没有高质量的数据，就没有高质量的数据挖掘结果
3.数据预处理的主要任务：数据清理（填充缺失值，识别/去除离群点，光滑噪音，并纠正数据中的不一致）、数据集成（多个数据库，数据立方体或文件的集成）、数据归约
4.pandas中None与np.nan都视作np.nan，在pandas中，None和np.nan统一处理成NaN，类型为float型，可用于计算且运算结果扔为NaN
5.isnull()如果为NaN就返回True，否则返回False；notnull() 如果为NaN就返回False，否则返回True；dropna(): 过滤丢失数据(NaN)；fillna(): 填充丢失数据(NaN)
6…notnull().any(axis=0) :判定列或行中存在是否存在缺失值，只要不存在则为True；.notnull().all(axis=0) 只要有一个为False，结果就为False
7.如何处理噪音数据：分箱、聚类、计算机和人工检查相结合、回归
8.实体识别是指从不同数据源识别出现实世界的实体，它的任务是统一不同源数据的矛盾之处：同名异义、异名同义、单位不统一
9.移除重复数据：drop_duplicates则可去除重复行
10.标称数据的卡方检验：𝝌𝟐值越大，相关的可能越大；相关不意味着因果关系
11.数值数据-相关分析：相关系数（皮尔逊相关系数）、协方差
12.数据归约：在大数据集上进行复杂的数据挖掘分析需要很长的时间，数据规约产生更小但保持原数据完整性的新数据集；维度归约、数量归约、数据压缩
13.维度规约：决策树规约、主成分分析、奇异值分解
14.数量规约：有参数方法是使用一个模型来评估数据，只需存放参数，而不需要存放实际数据；无参数方法就需要存放实际数据，例如直方图、聚类、抽样(简单随机抽样、无放回抽样、放回抽样、分层抽样)
15.数据变换主要是对数据进行规范化处理，将数据转换成适合挖掘的形式，以适用于挖掘任务及算法的需要
16.常用的离散化方法：等宽法、等频法、基于聚类分析的方法；Pandas离散化实现pandas.cut(x, bins, right=True, labels=None, retbins=False,include_lowest=False)
17.独热编码实例：df2 = pd.get_dummies(df1, columns=[‘姓名’, ‘班级’])
18.python主要预处理函数：interpolate(数据插值) unique(去除重复元素) isnull(判断是否空值) notnull(是否非空值) PCA random(随机矩阵)

第四章：数据仓库与数据立方体
1.数据仓库：是一个从多个数据源收集的信息存储库，存放在一致的模式下，并且通常驻留在单个站点上
2.数据仓库特点：相对简单的表格结构，存储结构相对松散，多冗余数据，一般只是读优化，相对复杂的，单次作用于相对大量的数据
3.数据仓库关键特征：面向主题、数据集成、随时间而变化、数据不易丢失
4.操作数据库系统的主要任务是联机事务处理(OLTP)和查询；数据仓库的主要任务是联机分析处理(OLAP)
5.数据仓库的概念模型：星型模式、雪花模式、事实星座
6.OLAP 操作：上卷、下钻、切块、转轴

第六章：挖掘频繁模式
1.关联规则反映一个事物与其他事物之间的相互依存性和关联性
2.频繁模式: 频繁出现在数据集中的模式(如项集、子序列或子结构)
3.支持度(support)：D中包含（集合A和B的并集）的百分比；置信度(confidence)：D中包含A的事务同时包含B的事务的百分比
4.若一个集合S2中的每一个元素都在集合S1中，且集合S1 中可能包含S2中没有的元素，则集合S1就是S2的一个超集
5.Apriori算法利用的是先验性质:1.频繁项集的所有非空子集也必须是频繁的、2.非频繁项集的超集一定是非频繁的
6.Apriori算法利用频繁项集性质的先验知识，通过逐层搜索的迭代方法，即将k-项集用于探察(k+1)-项集，来穷尽数据集中的所有频繁项集
7.不相同元素只有两个的k-1频繁项集才可以生成一个k待频繁项集
8.Apriori算法由连接和剪枝两个步骤组成：连接：为了找Lk，通过Lk -1与自己连接产生候选k-项集的集合，该候选k项集记为Ck，不相同元素只有两个的k-1频繁项集才可以生成一个k待频繁项集；剪枝：通过计算每个k-项集的支持度来得到Lk
9.Ck 先验知识缩减 Ck 支持度筛选 Lk
10.瓶颈问题：可能需要产生大量的候选项集、可能需要重复扫描整个数据库，通过模式匹配检验一个很大的候选集合
11.提高Apriori效率的方法：基于Hash的项集计数、减少交易记录、划分、抽样、动态项集计数
12.提升度：一种兴趣度的度量；P(AB)/P(A)P(B) 取值小于1 ，A and B 负相关,取值大于1 ，A and B 正相关与事务总数N相关
13.四种模式评估度量:全置信度,最大置信度,Kulczynski,余弦
14.不平衡比:(A-B)/(A+B-AB)

第八章：分类的基本概念
1.分类：利用已知类别的对象以预测未知对象属于哪个预定义的目标类
2.分类任务两步过程：学习阶段：利用已知类别的数据构建分类模型；预测阶段：利用构建分类模型对未知类别数据预测
3.过拟合(Overfitting): 给定一个假设空间H，一个假设h属于H，如果存在其他的假设ℎ′属于H，使得在训练样例上h的错误率比ℎ′小，但在整个实例分布上ℎ′比h的错误率小，那么就说假设h过度拟合训练数据
4.决策树技术发现数据模式和规则的核心是归纳算法；归纳：即从特殊事实到普遍性规律的结论
5.决策树算法步骤：1.树以代表训练样本的单个节点（N）开始；2.如果样本都在同一个类，则该节点成为树叶，并用该类标记；3.否则，算法调用Attribute_selection_method，选择能够最好的将样本分类的属性；确定“分裂准则”，指出“分裂点”或“分裂子集”；4.对测试属性每个已知的值，创建一个分支，并以此划分元组；5.算法使用同样的过程，递归的形成每个划分上的元组决策树。一旦一个属性出现在一个节点上，就不在该节点的任何子节点上出现；6.递归划分步骤停止的条件
6.常用的属性选择度量：信息增益、增益率、基尼指数（Gini指数）
7.信息增益(Information gain)表示得知特征A的信息而使得类决策属性信息的不确定性减少的程度
8.信息增益的缺陷：信息增益度量倾向于选择具有大量值的属性：当训练数据集的经验熵大时，信息增益偏大，反之信息增益偏小
9.三种度量通常会得到好的结果，但这些度量并非无偏的：信息增益（偏向于多值属性）、增益率（倾向于不平衡的划分，其中一个分区比其他分区小得多）、基尼指数（偏向于多值属性、当类的数量很大时会有困难）
10.决策树面临的问题：NP难题、过度拟合、连续属性不适应性问题（决策树算法比较适合处理离散数值的属性）
11.防止过分拟合的两种方法：先剪枝（选择一个合适的临界值往往很困难）、后剪枝
12.连续值处理问题：需要连续属性离散化，最常用的离散化策略是二分法，这个技术也是C4.5中采用的策略
13.离散型字符属性编码：独热编码( one-hot code) 缺点：当类别的数量很多时，特征空间会变得非常大
14.决策树缺陷：1.对连续型字段比较难预测 2.对于有时间顺序数据，需要许多预处理工作 3.当类别较多时，错误可能增加的比较快 4.对处理特征关联性比较强的数据时，表现的不是太好 5.一般的算法分类的时候，只是根据一个字段来分类
15.贝叶斯方法：在正确辅助信息的指引下，后验概率比先验概率对分类决策更有效
16.条件独立性假设在类别已知的条件下，各属性是相互独立的
17.朴素贝叶斯的优缺点-优点：1.朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率 2.对小规模的数据表现很好，能个处理多分类任务，适合增量式训练，尤其是数据量超出内存时，可以一批批的去增量训练 3.对缺失数据不太敏感，算法也比较简单，常用于文本分类；缺点：1.理论假设在实际应用中往往是不成立的，在属性个数比较多或者属性之间相关性较大时，分类效果不好 2.需要知道先验概率，且先验概率很多时候取决于假设 3.由于我们是通过先验和数据来决定后验的概率从而决定分类，所以分类决策存在一定的错误率 4.对输入数据的表达形式很敏感
18.近邻分类（k-NN）算法：急切学习法：当给定练元组集时，急切学习法( eager learner)在接收待分类的新元组(如检验元组)之前就构造泛化模型(即分类模型)，并急于对先前未见过的元组进行分类；惰性学习方法
19.核心思想:如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性;“K”表示分类考虑的数据集项目的数量
20.算法基本步骤:1.计算测定实例𝑥与每个训练实例𝑥𝑖(i=1,…,N)相似度𝑑𝑖 = 𝑠𝑖𝑚𝑖𝑙𝑎𝑟𝑦(𝑥, 𝑥𝑖)(默认越大越相似);2.按照𝑑𝑖由大到小的顺序将𝑥1, 𝑥2, … , 𝑥𝑁排序;3.取前K个样本作为𝑥的𝑘个近邻
21.常见的距离度量方式:闵可夫斯基距离(2欧氏距离 1曼哈顿距离)、Hamming distance (汉明距离)
22.K-NN 在高维空间中失效，这时候找到近邻点的距离相当远，以至于无法用于预测分类
23.神经网络：单层神经网络-感知机(perceptron)是二分类的线性分类模型，其输入为实例的特征向量，输出为实例的类别
24.常用的激活函数：sigmoid函数也称为Logistic函数，因为Sigmoid函数可以从Logistic回归中推理得到，也是LR模型指定的激活函数；Tanh(Hyperbolic Tangent)双曲正切函数，可看做是 sigmoid 向下平移和拉伸后的结果；Relu(Rectified Linear Unit)——修正线性单元函数：该函数形式比较简单
25.模型评估与选择（分类模型性能的度量）：混淆矩阵TP FN FP TN；常用的评估度量：准确率、识别率、错误率、误分类率、召回率
26.召回率(recall): 正确识别的正元组的百分比，即 TP/P；精度(precision)：预测标记为正类的元组实际为正类所占的比例，即TP/(TP+FP)；特效性(specificity)：正确识别的负元组的百分比，即 TN/N
27.精度和召回率之间区域呈现逆关系，有可能以降低一个为代价而提高另一个。往往用固定的召回率比较精度或用固定的精度比较召回率
28.分类模型的评估与选择：保持方法（给定的数据随机的划分为两个独立的集合：训练集、测试集）；随机二次抽样：保持方法的变形将保持方法重复k次，总准确率估计取每次迭代准确率的；交叉验证(k-折交叉验证)；留一法；分层交叉验证（每一折中都保持着原始数据中各个类别的比例关系）；自助法（从给定训练元组中有放回的均匀抽样作为训练集）
29.分类模型显著性检测：Wilcoxon秩和检验是最常用的的非参数检验方法，也称秩转换该方法在非参数检验中占有重要地位；显著性检验；检验p值
30.成分效益和ROC曲线：接受者操作特征曲线曲线(ROC)是一种比较两个分类模型有用的可视化工具。以概率为阈值来度量显示了模型正确识别正实例的比例与模型错误地把负实例识别成正实例比例权衡；

第十章：聚类概念和方法
1.簇：每个子集是一个簇；聚类分析：是一个把数据对象集划分成多个簇或组的过程，使得同一簇中的对象彼此相似不同簇中的对象彼此相异
2.数据挖掘对聚类的典型要求：可伸缩性、处理不同属性类型的能力、发现任意形状的聚类、用于决定输入参数的领域知识最小化、处理噪声数据和孤立点的能力、对于输入记录的顺序不敏感、高维性、整合用户指定的约束、可解释性和可用性
3.聚类方法的分类：划分方法、层次方法、基于密度方法、基于网格方法；大部分划分方法是基于距离
4.层次方法：凝聚方法, 也称为自底向上；分裂方法, 也称为自顶向下
5.基于密度的方法：基本思想:假设聚类结构能够通过样本分布的紧密程度确定，以数据集在空间分布上的稠密程度为依据进行聚类，即只要一个区域中的样本密度大于某个阈值，就把它划入与之相近的簇中；该方法可以用来过滤“噪音”数据，发现任意形状的簇
6.基于网格的方法：把对象空间量化为有限数目的单元, 形成了一个网格结构. 所有的聚类操作都在这个网格结构(即量化的空间)上进行
7.K-Means聚类算法：1.任意选择k个对象作为初始的簇中心；2.将所有对象划归为k个簇：计算所有对象到k个簇中心的距离并找出与每个对象最近的簇中心, 将该对象划分到该中心点所代表的的簇当中去；3.更新簇的平均值, 即重新计算每个簇中对象的平均值；4.until 对象归属的簇不再发生变化
8.SSE：对于任意给定的迭代聚类中心初值（或者任意给定的一种划分方式），算法的目标函数一定会收敛
9.文档数据：对于文档数据使用余弦相似度度量，先将文档数据先整理成文档-词矩阵格式
10.K-Means聚类算法优点：1.算法简单，容易实现；2.算法速度很快；3.对处理大数据集，该算法是相对可伸缩的和高效率的；4.当簇是密集的、球状或团状的，且簇与簇之间区别明显时，聚类效果较好
11.K-Means聚类算法不足：1.对数据类型要求较高，适合数值型数据；2.可能收敛到局部最小值，在大规模数据上收敛较慢
12.k-Modes作为k-Means的一种扩展，适用于离散属性的数据集
13.K-Means聚类算法对离群点（远离大多数据的数据）比较敏感：当将其分配至一个簇中时，可能严重扭曲簇的均值而影响了其他对象到簇的分配
14.k-中心点(k-Medoids): 不采用簇中对象的平均值作为参照点，而是选用簇中位置最中心的对象, 即中心点(medoid)作为参照点
15.围绕中心划分PAM；当存在噪音和孤立点时, PAM 比 k-平均方法更健壮. 这是因为中心点不象平均值那么容易被极端数据影响；PAM对于小数据集工作得很好, 但不能很好地用于大数据集
16.K-Means聚类算法只能发现球（或圆形）的类
17.密度聚类：基于密度的聚类算法假设聚类结构能够通过样本分布的紧密程度确定，以数据集在空间分布上的稠密程度为依据进行聚类，即只要一个区域中的样本密度大于某个阈值，就把它划入与之相近的簇中
18.DBSCAN：是基于一组邻域参数(ε，MinPts)描述样本分布的紧密程度将簇定义为密度相连的样本的最大集合，能够将密度足够高的区域划分为簇，不需要给定簇数量，并可在有噪声的空间数据集中发现任意形状的簇
19.密度直达：描述的是核心样本点与其𝜺-领域内的样本点的关系，是密度直达的；密度可达：描述的是核心对象与不在其𝜺-领域内的非核心点的关系，如果其可通过核心点间的传递密度直达，则密度可达；密度相连：描述的是不在同一𝜺-领域内的非核心对象之间的关系
20.DBSCAN密度聚类思想：由密度可达关系导出的最大密度相连的对象集合C ，即为一个簇
21.基本过程：1.它任意选择一个没有类别的核心对象作为种子，并找到所有这个核心对象能够密度可达的样本集合，即为一个聚类簇；2.接着继续选择另一个没有类别的核心对象去寻找密度可达的样本集合，这样就得到另一个聚类簇；3.一直运行到所有核心对象都有类别为止
22.聚类评估主要内容：1. 估计聚类趋势；2. 确定数据集中的簇数；3.测定聚类质量
23.聚类要求数据的非均匀分布
24.霍普金斯统计量(Hopkins Statistic)是一种空间统计量，检验空间分布的变量的空间随机性；H>0.5:很大的概率没统计有显著性的簇
25.确定簇数：肘方法；交叉验证法
26.测定聚类质量：所谓外在方法是一种依靠类别基准的方法，即已经有比较严格的类别定义时在讨论聚类是不是足够准确；“内在方法”不会去参考类簇的标准，而是使用轮廓系数进行度量
27.BCubed精度：一个对象的精度指示同一个簇中有多少个其他对象与该对象同属一个簇；Bcubed召回率：一个对象的召回率反映有多少同一类别的对象被分配在相同的簇中
28.轮廓系数：当o的轮廓系数值接近1时，包含o的簇是紧凑的，并且o远离其他簇，这是一种可取的情况
29.聚类分析流程：1.判定数据是否存在结构（霍普金斯统计量）；2.选择聚类算法和距离（或相似度）度量K-Means聚类算法：聚类簇数（肘方法或交叉验证）DBSCAN聚类算法：邻域半径Eps(肘方法)、MinPts(≥ 𝑛𝑑𝑖𝑚 + 1)；3.聚类质量：轮廓系数(未知类别)、Bcubed度量(已知类别)；4.聚类后簇的定义：雷达图、密度函数等可视化方法（主观性）

第十二章：离群点检测
1.离群点：假定使用一个给定的统计过程来产生数据对象集，离群点是一个数据对象，它显著不同于其他数据对象，好像它是被不同的机制产生的一样；明显偏离数据整体趋势的离群数据点
2.离群点的特点：1.离群点不同于噪声数据；2.离群点是有趣的，因为怀疑产生它们的机制不同于产生其他数据的机制；3.离群点检测还与演变数据集上的新颖性检测相关
3.噪声是被观测变量的随机误差或方差，在数据分析（包括离群点分析）中不令人感兴趣的；与许多其他数据分析和数据挖掘任务一样，应该在离群点检测前就删除噪声
4.离群点分析机制：离群点产生的机制不同于产生其他数据的机制、离群点检测还与演变数据集上的新颖性检测相关
5.离群点的类型：全局离群点、情景离群点、集体离群点
6.全局离群点（也称点异常）：在给定的数据集中，显著地偏离数据集中的其余对象
7.情境（或条件）离群点：在给定的数据集中，关于对象的特定情境，显著地偏离其他对象
8.集体离群点：在给定的数据中，这些对象作为整体显著偏离整个数据集
9.离群点检测方法：统计学方法、基于近邻性的方法、基于聚类的方法、基于分类的方法
10.对给定的数据集合假设了一个分布或概率模型(例如, 正态分布), 然后根据模型采用不一致性检验(discordancy test)来识别离群点
11.基于统计学的离群点检测：对给定的数据集合假设了一个分布或概率模型, 然后根据模型采用不一致性检验(discordancy test)来识别离群点
12.基于近邻的离群点检测：基于距离的离群点检测、基于密度的离群点检测
13.基于距离的离群点检测
14.基于密度的离群点检测：基于密度的离群点检测能够检测出基于距离的异常算法所不能识别的一类异常数据-局部离群点；局部离群点:是指一个对象相对于它的局部邻域，特别是关于邻域密度是远离的

PPT所含代码整理：
#----------------------------第二章认识数据------------------------------------------
import pandas as pd
df = pd.read_csv(r’C:\Users\86156\Desktop\pingjun.csv’)
print(df.describe()) #给出样本的基本描述

数据标准化转换

from sklearn.preprocessing import StandardScaler#标准化变换
from sklearn.preprocessing import MinMaxScaler#极差标准化变换
import numpy as np
data = np.random.uniform(0, 100, 10)[:, np.newaxis]

ss = StandardScaler()
std_data = ss.fit_transform(data)#归一化后的数据
origin_data = ss.inverse_transform(std_data)#原始数据
print(std_data)

mm = MinMaxScaler()
mm_data = mm.fit_transform(data)#归一化后的数据
origin_data = ss.inverse_transform(mm_data )#原始数据
print(mm_data)

#----------------------------第三章数据预处理------------------------------------------
isnull()如果为NaN就返回True，否则返回False
notnull() 如果为NaN就返回False，否则返回True
dropna(): 过滤丢失数据(NaN)
fillna(): 填充丢失数据(NaN)

df.dropna( axis=0， how=‘any’， thresh=None， subset=None，inplace=False)
axis=0或1，指定删除含有缺失值的列或行
how=‘all’或‘any’，‘all’表示删除全是缺失值的行（列），any’时表示删除只要含有缺失值的行（列）
thresh=n表示保留至少含有n个非na数值的行
thresh=n表示保留至少含有n个非na数值的行

df.fillna(value=None， method=None， axis=None， inplace=False， limit=None)
value：用于填充的空值的值
method： {‘backfill’，‘bfill’， ‘pad’，‘ffill’， None}， default None。定义了填充空值的方法， pad/ffill表示用前面行/列的值，填充当前行/列的空值， backfill/ bfill表示用后面行/列的值，填充当前行/列的空值；
axis：轴。0或‘index’，表示按行删除；1或‘columns’，表示按列删除；
inplace：是否原地替换。布尔值，默认为False；
limit：int， default None。如果method被指定，对于连续的空值，这段连续区域，最多填充前 limit 个空值（如果存在多段连续区域，每段最多填充前 limit 个空值）。如果method未被指定，在该axis下，最多填充前 limit 个空值（不论空值连续区间是否间断）

移除重复数据（行）
pd.drop_duplicates(subset=None， keep=‘first’， inplace=False…)
subset：列名，可选，默认为None
keep： {‘first’， ‘last’， False}，默认值 ‘first’
first：保留第一次出现的重复行，删除后面的重复行。
last: 删除重复项，除了最后一次出现。
False：删除所有重复项。
inplace：布尔值，默认为False，是否直接在原数据上删除重复项或删除重复项后返回副本。（inplace=True表示直接在原来的DataFrame上删除重复项，而默认值False表示生成一个副本。）

Pandas离散化实现

pandas.cut(x, bins, right=True, labels=None, retbins=False,include_lowest=False)
x：array-like输入的连续值数组，必须是一维的
bins : int, sequence of scalars, or pandas.IntervalIndex分组依据
right : bool, default True是否包含最右边的值。如果bins是[1, 2, 3, 4]，区间就是(1,2], (2,3], (3,4]。如果为False，不包含右边，区间就是(1,2), (2,3), (3,4)
labels : array or bool, optional每组的标签，长度必须和组的长度一致。如果分组是(1,2), (2,3), (3,4)，则标签的长度必须为3，表示每组的别名。如果为False，则只返回垃圾箱(bins)，不返回out。
retbins : bool, default False。（return bins缩写）是否返回垃圾桶(bins)，默认不返回。如果为True，cut将有两个返回值，第二个返回值类似 array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
include_lowest : bool, default False第一个桶的初始值是否包含在内。np.arange(0, 101, 10) 默认不包含0，第一个桶为(0, 10]。如果设置为True，则包含0，第一个桶就是(-0.001, 10.0]返回值
out：pandas.Categorical，Series或ndarray
bins：numpy.ndarray或IntervalIndex仅在retbins = True时返回

#----------------------------第六章挖掘频繁模式------------------------------------------
#Apriori---------------------------------------------------------------
from mlxtend.preprocessing import TransactionEncoder
dataset = [[‘Apple’, ‘Beer’, ‘Rice’, ‘Chicken’],
[‘Apple’, ‘Beer’, ‘Rice’],
[‘Apple’, ‘Beer’],
[‘Apple’, ‘Bananas’],
[‘Milk’, ‘Beer’, ‘Rice’, ‘Chicken’],
[‘Milk’, ‘Beer’, ‘Rice’],
[‘Milk’, ‘Beer’],
[‘Apple’, ‘Bananas’]]

te = TransactionEncoder()
te_ary = te.fit(dataset).transform(dataset) #将列表转化为独热编码
print(te_ary)

apriori(df, min_support=0.5, use_colnames=False, max_len=None, verbose=0)
df(DataFrame类型)：元素的取值为0/1 或True/False
min_support(float类型) : 最小支持度阈值
use_colnames(bool类型)：是否利用原始数据的项显示频繁项集 (默认项是整数)
max_len(int类型)：指定最长频繁项集的长度

association_rules(df, metric=‘confidence’, min_threshold=0.8, support_only=False)
df(DataFrame类型) ：列名为 [‘support’, ‘itemsets’]的频繁项集对象
metric(str类型)：信任度类型’support’, ‘confidence’, ‘lift’,‘leverage’, and ‘conviction’
min_threshold(float类型)：度量阈值
support_only(bool类型):是否只计算指定的信任度量

import pandas as pd #通过TransactionEncoder将数据转为需要格式
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori, association_rules
dataset = [[‘Milk’, ‘Onion’, ‘Nutmeg’, ‘Kidney Beans’, ‘Eggs’, ‘Yogurt’],
[‘Dill’, ‘Onion’, ‘Nutmeg’, ‘Kidney Beans’, ‘Eggs’, ‘Yogurt’],
[‘Milk’, ‘Apple’, ‘Kidney Beans’, ‘Eggs’],
[‘Milk’, ‘Unicorn’, ‘Corn’, ‘Kidney Beans’, ‘Yogurt’],
[‘Corn’, ‘Onion’, ‘Onion’, ‘Kidney Beans’, ‘Ice cream’, ‘Eggs’]]

te = TransactionEncoder()
te_ary = te.fit(dataset).transform(dataset)
df = pd.DataFrame(te_ary, columns=te.columns_) #将列表转化为df类型
print(df)
df=apriori(df, min_support=0.6, use_colnames=True)
print(df)
df=association_rules(df, metric=“confidence”, min_threshold=0.7)
print(df)

#FPTree---------------------------------------------------------------
frequent_itemsets(X, min_support=0.2) #生成频繁项集
min_support：给定的最小支持度阈值.
X (整数list 或布尔 numpy.ndarray 或 scipy.sparse.spmatrix 或 iterator)：整数列表，即列表中的每个元素（每个事务）为整数列表；若为二维布尔数组数据，其中每一行（由布尔向量标识地）为一条事务数据

association_rules(itemsets, min_confidence, itemset=None)
itemsets (dict)：频繁项集(字典类型的).
min_confidence (float)：信任度阈值
itemset (frozenset) ：指定的频繁项集

fpgrowth.rules_stats(rules, itemsets, n_examples)
rules (iterable) ：由 association_rules()生成的关联规则；
itemsets (dict) ：字典格式的频繁项集.
n_examples (int) ：总事务数目

from orangecontrib.associate.fpgrowth import * #关联
T = [[1,3,4],
[2,3,5],
[1,2,3,5],
[2,5]]
itemsets = dict(frequent_itemsets(T,2)) #生成一个可迭代对象
print(itemsets)

from orangecontrib.associate.fpgrowth import * #关联
import numpy as np
np.random.seed(0)
X = np.random.random((50, 100)) > .9
itemsets = dict(frequent_itemsets(X, .05))
rules = association_rules(itemsets, .5)
rules = list(rules)

#----------------------------第八章分类：基本概念和方法------------------------------------------
#决策树---------------------------------------------------------------
实现步骤：
读取数据：离散型数值数据调用Sklearn库
离散型字符串数据独热编码调用Sklearn库

Sklearn库使用的基本框架

from sklearn.tree import DecisionTreeClassifier#导入模块
tree=DecisionTreeClassifier() #创建模型对象
tree.fit(X_train,y_train) #调用模型对象方法和属性
tree.predict(X_test)
tree.score(X_test,y_test)

clf = sklearn.tree.DecisionTreeClassifier(criterion=’gini’, splitter=’best’, max_depth=None,
min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0,
max_features=None, random_state=None, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None, class_weight=None, presort=False)
Criterion:特征选择的标准{“gini”, “entropy”}
splitter:指明在哪个集合上来递归，best表示在所有特征上递归，适用于数据集较小的时候，random表示随机选择一部分特征进行递归，适用于数据集较大的时候
减枝操作：
max_depth:决策树最大深度;
min_impurity_decrease:限制信息增益的大小
min_samples_split:子数据集再切分需要的最小样本量
min_samples_leaf:叶节点（子数据集）最小样本数
max_features:限制分枝时考虑的特征个数

from sklearn import tree
X = [[0, 0], [1, 1]]
Y = [“红”, “黑”]
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X, Y)
clf.predict([[2., 2.]])
clf.predict_proba([[2., 2.]])

sklearn实现独热编码

OneHotEncoder(categories=‘auto’, drop=None, sparse=True, dtype=np.float64, handle_unknown=‘error’)
categories=‘auto’时，编码时特征的取值取决于输入编码数据的特征取值，两者的
取值范围是一致的。categories取值为list时，编码时特征的取值为输入list的取值;
len(list_features)等于特征的数量，list_features中每个元素(eg:list_feature_values)又是一个list
handle_unknown：可以为字符串、error、ignore
parse：若为True时，返回稀疏矩阵，否则返回数组，默认为True

from sklearn.preprocessing import OneHotEncoder
import pandas as pd
attr_arr=[[‘slashdot’,‘USA’,‘yes’,18,‘None’],
[‘google’,‘France’,‘yes’,23,‘Premium’],
[‘digg’,‘USA’,‘yes’,24,‘Basic’],
[‘kiwitobes’,‘France’,‘yes’,23,‘Basic’],
[‘google’,‘UK’,‘no’,21,‘Premium’],
[‘(direct)’,‘New Zealand’,‘no’,12,‘None’],
[‘(direct)’,‘UK’,‘no’,21,‘Basic’],
[‘google’,‘USA’,‘no’,24,‘Premium’],
[‘slashdot’,‘France’,‘yes’,19,‘None’],
[‘digg’,‘USA’,‘no’,18,‘None’],
[‘google’,‘UK’,‘no’,18,‘None’],
[‘kiwitobes’,‘UK’,‘no’,19,‘None’],
[‘digg’,‘New Zealand’,‘yes’,12,‘Basic’],
[‘slashdot’,‘UK’,‘no’,21,‘None’],
[‘google’,‘UK’,‘yes’,18,‘Basic’],
[‘kiwitobes’,‘France’,‘yes’,19,‘Basic’]]
df = pd.DataFrame(attr_arr)
enc = OneHotEncoder()
inputs = enc.fit_transform(df.iloc[:,:-1]).toarray()
print(inputs)

决策树模型构建实例

from sklearn.preprocessing import OneHotEncoder
from sklearn import tree
import pandas as pd
attr_arr=[[‘slashdot’,‘USA’,‘yes’,18,‘None’],
[‘google’,‘France’,‘yes’,23,‘Premium’],
[‘digg’,‘USA’,‘yes’,24,‘Basic’],
[‘kiwitobes’,‘France’,‘yes’,23,‘Basic’],
[‘google’,‘UK’,‘no’,21,‘Premium’],
[‘(direct)’,‘New Zealand’,‘no’,12,‘None’],
[‘(direct)’,‘UK’,‘no’,21,‘Basic’],
[‘google’,‘USA’,‘no’,24,‘Premium’],
[‘slashdot’,‘France’,‘yes’,19,‘None’],
[‘digg’,‘USA’,‘no’,18,‘None’],
[‘google’,‘UK’,‘no’,18,‘None’],
[‘kiwitobes’,‘UK’,‘no’,19,‘None’],
[‘digg’,‘New Zealand’,‘yes’,12,‘Basic’],
[‘slashdot’,‘UK’,‘no’,21,‘None’],
[‘google’,‘UK’,‘yes’,18,‘Basic’],
[‘kiwitobes’,‘France’,‘yes’,19,‘Basic’]]
df = pd.DataFrame(attr_arr)
enc = OneHotEncoder()
inputs = enc.fit_transform(df.iloc[:,:-1]).toarray()#注意预测的那一列不需要独热编码
label = df.iloc[:,-1] #最后一列是我们要预测的内容
clf = tree.DecisionTreeClassifier()
clf.fit(inputs[:5,:],label[:5])#训练模型用前5行训练
pre = clf.predict(inputs[5:,:])#模型预测用5行后的内容预测
score = clf.score(inputs[5:,:], label[5:])#测试模型精度用训练模型预测得分

模型可视化代码

import graphviz
from sklearn import tree
feature_name = [“用户的来源网站”,“位置”,“是否阅读FAQ”,“浏览网页数”]
#这里加上模型的训练得到clf就可以用了
dot_data = tree.export_graphviz(clf ,feature_names=feature_name, class_names=[‘Basic’, ‘Premium’,‘None’] ,filled=True ,rounded=True)# 圆角
graph = graphviz.Source(dot_data)
#在tree.export_graphviz()中，会生成dot文件
graph = graphviz.Source(dot_data)#利用graphviz模块的Source()函数可以将其转化为gv文件

#朴素贝叶斯---------------------------------------------------------------
scikit-learn中提供了3中朴素贝叶斯分类算法：GaussianNB(高斯朴素贝叶斯)、MultinomialNB(多项式朴素贝叶斯)、BernoulliNB(伯努利朴素贝叶斯)。
高斯朴素贝叶斯：适用于连续型数值，比如身高在160cm以下为一类，160-170cm为一个类，则划分不够细腻。
多项式朴素贝叶斯：常用于文本分类，特征是单词，值是单词出现的次数。
补充朴素贝叶斯：CNB是标准多项式朴素贝叶斯(MNB)算法的一种改进，特别适用于不平衡数据集
伯努利朴素贝叶斯：所用特征为全局特征，只是它计算的不是单词的数量，而是出现则为1，否则为0。也就是特征等权重

bayesmodel=sklearn.naive_bayes.GaussianNB(priors=None)
priors:array-like,shape(n_classes,)#类别的先验概率，如果指定则不会根据数据改变
fit(X, y[, sample_weight]) #根据X,y训练高斯朴素贝叶斯模型
get_params([deep]) #获得参数
partial_fit(X, y[, classes, sample_weight]) #每次用一批样本增量拟合连续在不同的大量数据集上进行拟合
predict(X) #对测试向量X分类预测
predict_log_proba(X) #每个样本属于每个类别的概率的log值
predict_proba(X) #每个样本属于每个类别的概率
score(X, y[, sample_weight]) #Return the mean accuracy on the given test data and labels.
set_params(**params) #Set the parameters of this estimator

#近邻分类算法---------------------------------------------------------------

Sklearn归一化函数

from sklearn import preprocessing
X_scaled = preprocessing.scale(X)
min_max_scaler = preprocessing.MinMaxScaler()
X_train_minmax = min_max_scaler.fit_transform(X_train)

sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, weights=’uniform’,
algorithm=’auto’, leaf_size=30, p=2, metric=’minkowski’, metric_params=None,**kwargs)
n_neighbors：选择最邻近点的数目k
weights：邻近点的计算权重值，uniform代表各个点权重值相等
algorithm：寻找最邻近点使用的算法{‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}
leaf_size：传递给BallTree或kTree的叶子大小，这会影响构造和查询的速度，以及存储树所需的内存
p： Minkowski度量的指数参数。p = 1 代表使用曼哈顿距离 (l1)，p = 2 代表使用欧几里得距离(l2)，
metric：距离度量，点之间距离的计算方法
metric_params：额外的关键字度量函数
n_jobs：为邻近点搜索运行的并行作业数

from sklearn.datasets import make_classification
from sklearn.neighbors import KNeighborsClassifier
x,y=make_classification(n_samples=1000,n_features=2,n_informative=2,n_redundant=0,n_clusters_per_class=1,n_classes=3)
#将样本分为训练数据和测试数据
x_train = x[:800]
y_train = y[:800]
x_test = x[800:]
y_test = y[800:]
clf=KNeighborsClassifier(n_neighbors=3)
clf.fit(x_train,y_train)#进行训练
clf.predict(x_test,y_test)#测试训练成绩

#KDTree(KNN的优化)---------------------------------------------------------------
sklearn.neighbors.KDTree(X, leaf_size=40, metric=‘minkowski’, **kwargs)

from sklearn import datasets
from sklearn.neighbors import KDTree
X, y = datasets.load_iris(return_X_y=True)
tree = KDTree(X)
dist_to_knn, idx_of_knn = tree.query(X=X[[3]],k=5)
print(dist_to_knn) # 到k个近邻的距离
print(idx_of_knn) # k个近邻的索引

#神经网络---------------------------------------------------------------
感知机
from sklearn.linear_model import Perceptron
clf= Perceptron( (penalty=None, alpha=0.0001, l1_ratio=0.15, fit_intercept=True, max_iter=1000,
tol=0.001, shuffle=True, verbose=0, eta0=1.0, n_jobs=None, random_state=0, early_stopping=False,
validation_fraction=0.1, n_iter_no_change=5, class_weight=None, warm_start=False)
➢ penalty:{‘l2’,’l1’,’elasticnet’}, default=None(正则化项)
➢ alpha: float, default=0.0001（惩罚因子）
➢ fit_intercept:bool, default=True(偏置项)
➢ max_ite: int整数，默认=1000(最大迭代次数)
➢ l1_ratio:默认0.15，取值在0,1
➢ random_state: 用于打乱训练数据
➢ early_stopping：是否设置提前停止终止训练
➢ max_ite: int整数，默认=1000(最大迭代次数)

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
from sklearn.linear_model import Perceptron
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
data = np.array(df)
X, y = data[:,:-1], data[:,-1]
y[y==0] = -1
perceptron = Perceptron(fit_intercept=True, max_iter=1000, shuffle=True)
perceptron.fit(X, y) # 默认学习率为1

多层感知机
from sklearn.neural_network import MLPClassifier
clf= MLPClassifier(hidden_layer_sizes=(100), activation=‘relu’, *, solver=‘adam’,
alpha=0.0001, batch_size=‘auto’, learning_rate=‘constant’, learning_rate_init=0.001)

hidden_layer_sizes :tuple, length = n_layers - 2, default=(100,)。
activation :激活函数,{‘identity’, ‘logistic’, ‘tanh’, ‘relu’}, 默认relu
solver：权重优化方法{‘lbfgs’, ‘sgd’, ‘adam’}, 默认adam
batch_size : int , 随机优化的minibatches的大小
learning_rate :学习率, {‘constant’，’invscaling’, ‘adaptive’}

from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(n_samples=100, random_state=1)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=1)
clf = MLPClassifier(random_state=1, max_iter=300).fit(X_train, y_train)
clf.predict_proba(X_test[:1])
array([[0.038…, 0.961…]])
clf.predict(X_test[:5, :])
array([1, 0, 1, 0, 1])
clf.score(X_test, y_test)

#模型评估与选择---------------------------------------------------------------
sklearn.metrics.f1_score(y_true, y_pred, labels=None, pos_label=1, average=‘binary’, sample_weight=None,zero_division=‘warn’)
y_true：1d数组，或标签指示符数组/稀疏矩阵基本事实（正确）目标值
y_pred：1d数组，或标签指示符数组/稀疏矩阵分类器返回的估计目标
average：string, [None, ‘binary’ (default), ‘micro’, ‘macro’, ‘samples’, ‘weighted’]对于多类/多标签目标，此参
数是必需的。如果为None，则返回每个班级的分数。否则，这将确定对数据执行的平均类型：
‘binary’：仅报告由指定的类的结果pos_label。仅在目标（y_{true,pred}）为二进制时适用
‘micro’：通过计算正确，错误和否定的总数来全局计算指标
‘macro’：计算每个标签的指标，并找到其未加权平均值。这没有考虑标签不平衡

from sklearn.metrics import accuracy_score,precision_score,recall_score,f1_scor
y_true = np.array([[0, 1, 1], [0, 1, 0]])
y_pred = np.array([[1, 1, 1], [0, 0, 1]])
y_true = np.reshape(y_true, [-1])
y_pred = np.reshape(y_pred, [-1])
p = precision_score(y_true, y_pred, average='binary’)
r = recall_score(y_true, y_pred, average='binary’)
f1score = f1_score(y_true, y_pred, average=‘binary’)

#交叉验证代码
#保持方法(holdout)
from sklearn.model_selection import train_test_split
train_X , test_X, train_Y ,test_Y = train_test_split( X, Y, test_size=0.2,random_state=0)
#K折交叉验证
from sklearn.model_selection import KFold
kf = KFold(n_splits=10) for train,valid in kf.split(X_data)
#留一法
from sklearn.model_selection import LeaveOneOut
oo = LeaveOneOut() train, test in loo.split(data)

显著性检测

import scipy.stats as stats
stats.wilcoxon( x, y, correction = Flase, alternative = ‘two-sided’ )
x：第一组测量值（在这种情况下，y是第二组测量值），或者在两组测量值之间的差（在这种情况下，不指定y）。必须是一维的。
y：第二组测量值（如果x是第一组测量值），或者未指定（如果x是两组测量值之间的差）。必须是一维的。
correction：如果为True，则是在小样本情况下，在计算Z统计量时用0.5来连续性校正。默认值为False。
alternative：等于 “two-sided” 或 “greater” 或 “less”。“two-sided” 为双边检验，“greater” 为备择假设是大于的单边检验，“less” 为备择假设是小于的单边检验。

import scipy.stats as stats
x=[310,350,370,377,389,400,415,425,440,295,325,296,250,340,298,365,375,
360,385]
y=[320]*len(x)
stats.wilcoxon(x,y,correction=True,alternative=‘greater’)
WilcoxonResult(statistic=158.0, pvalue=0.005949317582258638)

#ROC曲线
from sklearn.metrics import roc_curve, auc
fpr, tpr, thresholds = roc_curve(y_test, scores)
输入：y_test为测试集的结果，在范围{0,1}或{-1,1}中真正的二进制标签；scores为测试元组的属于正例的概率;
输出：fpr，tpr，thresholds 分别为不同阈值下的真正率和假正率。
计算的acu的值：roc_auc =auc(fpr, tpr)

#----------------------------第十章聚类：基本概念和方法------------------------------------------
#K-means
sklearn.cluster.KMeans(n_clusters=8, *, init=‘k-means++’, n_init=10, max_iter=300,
tol=0.0001, precompute_distances=‘deprecated’, verbose=0, random_state=None,
copy_x=True, n_jobs=‘deprecated’, algorithm=‘auto’)
n_clusters：整形，生成的聚类数，即产生的簇的数；
init：有三个可选值：’k-means++’，‘random’，或者传递一个ndarray向量
copy_x：布尔型，默认值=True；当计算距离时，将数据中心化会得到更准确的结果。如果把此参数值设为True，则原始数据不会被改变。如果是False，则会直接在原始数据。

fit(X[,y]):计算k-means聚类。
fit_predictt(X[,y]):计算簇质心并给每个样本预测类别。
fit_transform(X[,y])：计算簇并 transform X to cluster-distance space。
get_params([deep])：取得估计器的参数。
predict(X):给每个样本估计最接近的簇。
score(X[,y]):计算聚类误差
transform(X[,y]): 将X转换为群集距离空间。在新空间中，每个维度都是到集群中心的距离。请注意，即使X是稀疏的，转换返回的数组通常也是密集的

#DBSCAN
sklearn.cluster.DBSCAN(eps=0.5, min_samples=5, metric=‘euclidean’, algorithm=‘auto’, leaf_size=30, p=None, n_jobs=1)
eps:两个样本之间的最大距离，即扫描半径
min_samples ：作为核心点的话邻域(即以其为圆心，eps为半径的圆，含圆上的点)中的最小样本数(包括点本身)。
metric：度量方式，默认为欧式距离，还有metric=‘precomputed’（稀疏半径邻域图）
algorithm：近邻算法求解方式，有四种：‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’
leaf_size：叶的大小，在使用BallTree或cKDTree近邻算法时候会需要这个参数
from sklearn import datasets
estimator = DBSCAN(eps=0.5,min_samples=3)
#构造聚类器,一个参数是半径，一个是密度
estimator.fit(iris_x)
label_pred = estimator.labels_ #获取聚类标签
#绘制k-means结果
x0 = iris_x[label_pred == 0]
x1 = iris_x[label_pred == 1]
plt.scatter(x0[:, 0], x0[:, 1], c = “red”, marker=‘o’, label=‘label0’)
plt.scatter(x1[:, 0], x1[:, 1], c = “green”, marker=‘*’, label=‘label1’)
plt.show()

#聚类评估
Bcubed度量
import bcubed
precision = bcubed.precision(cdict, ldict)#集群输出、黄金标准数据
recall = bcubed.recall(cdict, ldict)
fscore = bcubed.fscore(precision, recall)

轮廓系数
from sklearn import metrics
from sklearn import datasets
dataset = datasets.load_iris()
X = dataset.data
from sklearn.cluster import KMeans
kmeans_model = KMeans(n_clusters=3, random_state=1).fit(X)
labels = kmeans_model.labels_
metrics.silhouette_score(X, labels, metric=‘euclidean’) #轮廓系数（silhouette coefficient）

实验代码整理：
实验一、四和补充是要考的内容，其余是实验的总结

################################实验一关联规则##################################
#Apriori算法
有时我们并不想寻找所有频繁项集,而只对包含某个特定元素项的项集感兴趣。我们会寻找毒蘑菇中的一些公共特征,利用这些特征
就能避免吃到那些有毒的蘑菇。UCI 的机器学习数据集合中有一个关于肋形蘑菇的 23 种特征的数据集,每一个特征都包含个标称数据值。
我们必须将这些标称值转化为一个集合。幸运的是,已经有人已经做好了这种转换。Roberto Bayardo 对 UCI 蘑菇数据集进行了解析,将每
个蘑菇样本转换成一个特征集合(mushroom.dat)。其中,枚举了每个特征的所有可能值,如果某个样本包含特征,那么该特征对应的整数值被
包含数据集中。
1.数据准备
读取数据集“mushroom.dat”文件，并只选择有毒蘑菇的数据。
注意删除存在缺失值的行数据
2.数据建模
调用 aprior 或 FP 树算法，其中选择支持度阈值 0.4。
3. 分析结果输出
只输出与毒蘑菇相关的属性值构成的频繁项集(例如，[“2”,”59”])

要求：
把行号为2（有毒）的频繁项集找出来删除含有缺失值的行
aprior算法或者FP算法支持度为0.4
输出结果：输出与毒蘑菇相关的属性值构成的频繁项集

import pandas as pd
#读取经过数据处理后的csv文件
data=pd.read_csv(r’Mushroom处理后.csv’,encoding=‘gbk’,index_col=[‘是否为毒蘑菇’])

print(data.describe()) #查看count等信息 count=4208

data=data.dropna(axis=1,how=‘any’) #删除含有缺失值的行

print(data.describe()) #查看count等信息 count=4208 所以没有缺失信息

#aprior算法支持度阈值为0.4

先将数据转化为需要的格式 array 和 list 格式都可以

data=data.values.tolist()

#转换为关联规则需要的格式
from mlxtend.preprocessing import TransactionEncoder
te = TransactionEncoder()
te_ary = te.fit(data).transform(data)
df = pd.DataFrame(te_ary, columns=te.columns_)

print(df) #查看数据

from mlxtend.frequent_patterns import apriori
answer=apriori(df, min_support=0.4,use_colnames=True)
print(answer)

#Apriori

#癌症实验
1.数据离散化
2.最小支持度 6%、最小置信度 75%
3.我们只在乎那些以 H 为规则结果的规则

import pandas as pd
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori,association_rules

te = TransactionEncoder()

df = pd.read_excel(r’cancer.xls’)

df[“肝气郁结证型系数”] = pd.cut(df[“肝气郁结证型系数”], [0,0.179,0.258,0.35,0.504], labels=[“A1”, “A2”, “A3”, “A4”],include_lowest=True)
df[“热毒蕴结证型系数”] = pd.cut(df [“热毒蕴结证型系数”], [0,0.15,0.296,0.485,0.78], labels=[“B1”, “B2”, “B3”, “B4”],include_lowest=True)
df[“冲任失调证型系数”] = pd.cut(df[“冲任失调证型系数”], [0,0.201,0.288,0.415,0.61], labels=[“C1”, “C2”, “C3”, “C4”],include_lowest=True)
df[“气血两虚证型系数”] = pd.cut( df[“气血两虚证型系数”], [0,0.172,0.251,0.357,0.552], labels=[“D1”, “D2”, “D3”, “D4”],include_lowest=True)
df[“脾胃虚弱证型系数”] = pd.cut( df[“脾胃虚弱证型系数”], [0,0.154,0.256,0.375,0.526], labels=[“E1”, “E2”, “E3”, “E4”],include_lowest=True)
df[“肝肾阴虚证型系数”] = pd.cut( df[“肝肾阴虚证型系数”], [0,0.178,0.261,0.353,0.607], labels=[“F1”, “F2”, “F3”, “F4”],include_lowest=True)
b = df.values.tolist()
te_ary = te.fit(b).transform(b)

df = pd.DataFrame(te_ary, columns=te.columns_)
fre_itemset = apriori(df, min_support=0.06,use_colnames=True)

rules =association_rules(fre_itemset, metric=‘confidence’, min_threshold=1, support_only=False)
consequents = rules[‘consequents’] #frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
idx = consequents.apply(lambda x: ‘H4’ in set(x))
aim_rules = rules[idx]
print(aim_rules)

################################实验二K 近邻分类：海伦交友案例##################################
我的朋友海伦一直使用在线约会网站寻找适合自己的约会对象。尽管约会网站会推荐不同的人选,但她没有从中找到喜欢的人。经过
一番总结，她发现曾交往过三种类型的人：“不喜欢的人”、“魅力一般的人”以及“极具魅力的人”。尽管发现了上述规律,但海伦依然无
法将约会网站推荐的匹配对象归人恰当的分类。她觉得可以在周一到周五约会那些魅力一般的人，而周末则更喜欢与那些极具魅力的人为
伴。海伦希望我们的分类软件可以更好地帮助她将匹配对象划分到确切的分类中。此外海伦还收集了一些约会网站未曾记录的数据信息,
她认为这些数据更有助于匹配对象的归类。
1.数据准备：海伦收集约会数据已经有了一段时间，她把这些数据存放在文本文件 dating TestSet. txt 中,
每个样本数据占据一行，总共有 1006 海伦的样本主要包含以下 3 种特征:“每年获得的飞行常客里程数”、“玩
视频游戏所耗时间百分比”以及“每周消费的冰淇淋公升数”。
2.数据预处理：因数据属性的量纲不一致，需要进行归一化处理。
3.数据建模：在分类准确率准则指导下，利用十折交叉验证确定最优的参数 k。
4.模型预测：上面我们已经在数据上对分类器进行了测试,现在终于可以使用这个分类器为海伦来对人们分类。我们会给海伦一小段程序，通过该
程序海伦会在约会网站上找到某个人并输入他的信息。程序会给出她对对方喜欢程度的预测值
from sklearn.preprocessing import MinMaxScaler #数据归一化处理
import pandas as pd
from sklearn.model_selection import train_test_split
import mglearn
from sklearn.neighbors import KNeighborsClassifier #导入k近邻分类器
import numpy as np
from sklearn.model_selection import StratifiedKFold

#读取文件
data = pd.read_csv(‘datingTestSet.txt’,sep=‘\t’,encoding=‘utf-8’,names=[“每年获得的飞行常客里程数”,“玩视频游戏所耗时间百分比”,“每周消费的冰淇淋公升数”,“类型”])
x = data[[“每年获得的飞行常客里程数”,“玩视频游戏所耗时间百分比”,“每周消费的冰淇淋公升数”]]
y = data[“类型”]

#数据归一化处理
mm = MinMaxScaler()
mm_data = mm.fit_transform(x)#归一化后的数据

print(mm_data)

x=np.array(mm_data)
y=np.array(y)

print(X_train)

print(Y_train)

#折的数量，数据打乱顺序，随机数种子无
kf = StratifiedKFold(n_splits = 10, shuffle=True, random_state=None) # 10折
scores=[]
predict=[]
for train_index, test_index in kf.split(x,y): # 将数据划分为k折
train_data = train_index # 选取的训练集数据下标
test = test_index # 选取的测试集数据下标
# print(test)
# x_train=x.loc[train_data,:]
data1=data.loc[train_data,:] #训练集
data2=data.loc[test,:] #测试集
x_train=data1[[“每年获得的飞行常客里程数”,“玩视频游戏所耗时间百分比”,“每周消费的冰淇淋公升数”]]
y_train=data1[“类型”]
x_test=data2[[“每年获得的飞行常客里程数”,“玩视频游戏所耗时间百分比”,“每周消费的冰淇淋公升数”]]
y_test=data2[“类型”]
clf = KNeighborsClassifier(n_neighbors=3) #假设近邻数为3 这个地方可以手动改一改，找出来哪个值最合适
#对分类器clf实施训练
clf.fit(x_train,y_train)
#使用predict函数对测试集进行预测
# print(‘测试集预测结果为：{}’.format(clf.predict(x_test)))
predict.append(clf.predict(x_test))
# print(‘测试集准确度：{:.2f}’.format(clf.score(x_test,y_test)))
scores.append(clf.score(x_test,y_test))
index_max=scores.index(max(scores)) #获取最好的模型得分下标

print(index_max)

predict_max=predict[index_max] #最佳预测结果

print(predict_max)

#################################实验三朴素贝叶斯##################################
import pandas as pd
import numpy as np
X=[“<=30”,“medium”,“yes”,“fair”]
data=pd.read_csv(“Computers.txt”,encoding=“utf-8”)
column_id=data.columns
label=data[column_id[-1]]#获取类标签
P_apriori=label.value_counts()/len(label)
group=data.groupby(column_id[-1])
p_label=np.empty((len(column_id)-1,label.nunique()))
for i in range(len(column_id)-1):
count=group[column_id[i]].value_counts().unstack()
count.fillna(0)#填充缺失值
p_label[i,:]=count[X[i]]/(count.sum(axis=1))
P_X=pd.DataFrame(p_label,columns=group.groups.keys())
P_X=P_X.prod()
P_bayes=P_X*P_apriori
print(f"预测结果为{P_bayes.idxmax()}")

##classes=label.unique()

count=group[column_id[i]].value_counts()

idx=[ (ele,X[i]) for ele in classes]

a=count[idx]

b=label.value_counts().sort_index()

p_label[i,:]=a.values/b.values

##P_X=pd.DataFrame(p_label,columns=[“no”,“yes”],index=data.columns[:-1])
##P_X=P_X.prod()
##P_bayes=P_X*P_apriori
##print(f"预测结果为{P_bayes.idxmax()}")

################################实验四 K-means 聚类建模##################################
某个餐饮公司因前期经验不善的影响而生意惨淡，现有位“接盘
侠”接受了此餐厅。他为了扭转此现状，通过“充值 200 送 20 元”、“充
值 500 元送 50 元”等优惠方式办理了几百张就餐充值卡，若干个月后
收集了 500 名顾客的“最近一次消费时间间隔”（R）、“消费频率”（F）、
“消费总额”（M）三类消费行为数据。此 “接盘侠”试图利用此数据将
客户进行分类成不同客户群，并评价这些客户群的价值，进行实行做
到针对性服务。然而此“接盘侠”不懂得对这些数据进行分析，你可以
帮助他吗？（数据集为 consumption_data.xls）

2.先验知识
2.1 因此餐饮店员工的失误导致收集的数据存在属性值缺失的情况
2.2 此数据中各属性的量纲(单位)不一致；
2.3 “接盘侠”凭借“砖家”的经验得知需要将客户划分为 3 个群体（簇），即优质客户、一般客户、低价值客户。

3.1 数据预处理：去除缺省值(pandas. dropna(…)方法)
3.2 数据归一化：因各属性存在量纲 ( 单位 ) 不一致
(sklearn.preprocessing.sclae()等类似方法)
3.3 数据聚类：利用欧式距离和 k-means 聚类对客户进行分群，聚类结果如下图所示（注意：因初始“类”中心和
停止准则的不同每个人得到结果不一样）
3.4. 密度函数绘制
为了对群体进行识别。针对每个群体的每个属性画出概率密度函数图
像。(pandas.Series.plot(kind=“kde”)方法)

K-means 聚类建模

import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.cluster import KMeans #这里直接导入KMeans类进行聚类
import matplotlib.pyplot as plt
plt.rcParams[‘font.sans-serif’]=[‘SimHei’] #用来正常显示中文标签
plt.rcParams[‘axes.unicode_minus’]=False #用来正常显示负号

data = pd.read_excel(r’consumption_data.xls’) #[946 rows x 4 columns]
#数据预处理
data=data.dropna() #[940 rows x 4 columns]
#将处理结果保存到文件中
data.to_csv(“consumption_data_数据处理.csv”,index=False)
data= pd.read_csv(r’consumption_data_数据处理.csv’,encoding=“utf-8”)
X=data[[“R”,“F”,“M”]]

#极差标准化变换-消除量纲
mm = MinMaxScaler()
mm_data = mm.fit_transform(X)#归一化后的数据

在此提一句，Python的Stick-learn库中所封装的K-means聚类算法，其底层代码所采用的距离度量方法默认为欧式距离。并且不可通过调用方法时的参数设定进行修改。

k_means = KMeans(n_clusters=3, random_state=0,n_init=20,max_iter=500) # #n_clusters：聚类中心的个数，n_init：初始化聚类中心的次数默认10，max_iter：迭代次数默认300；random_state=0:随机数种子
k_means.fit(mm_data)
#得到分类结果
y_pred = k_means.predict(mm_data)
#将分类结果保存在文件中
y_pred=pd.DataFrame(y_pred,columns=[“分类”])
data=data.join(y_pred)
data.to_csv(r"consumption_data_cluster.csv",index=False)

#密度函数绘制 #绘制九张图像
for i in range(3):
plt.figure(figsize=(20, 8), dpi=80)
plt.subplot(3,1,1)
data[data[“分类”]==i][“R”].plot(kind=“kde”)
plt.legend((‘R’),loc=‘best’)
plt.subplot(3,1,2)
data[data[“分类”]==i][“F”].plot(kind=“kde”)
plt.legend((‘F’),loc=‘best’)
plt.subplot(3,1,3)
data[data[“分类”]==i][“M”].plot(kind=“kde”)
plt.legend((‘M’),loc=‘best’)
plt.xlabel(“分类{}内每个属性的概率密度函数”.format(i))
plt.ylabel(“密度”)
plt.title(“各属性分布”)
plt.show()

分类 0 特点：R 间隔相对较小,主要集中在 0~25 天、消费次数集中1-8 次; 消费金额在 0~2000。价值较低的客户群体

分类 1 特点:R 间隔分布在 0~30 天;消费次数集中在 15~30 次;消费金额在 0~2400。消费、高价值人群

分类 2 特点:R 间隔相对较大,间隔分布在 0~40 天;消费次数集中在5~18 次;消费金额在 0~2400。一般客户

################################实验五 DBSCAN 聚类算法##################################

利用随机模拟生成的二维数据点，观察 K-means 聚类算法与

DBSCAN算法间的聚类区别，并观察在不同参数的条件下聚类效果。

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
X1, y1=datasets.make_circles(n_samples=5000, factor=.6,noise=.05) #生成圆形的数据
X2, y2 = datasets.make_blobs(n_samples=1000, n_features=2, centers=[[1.2,1.2]], cluster_std=[[.1]],random_state=9) #生成点数据
X = np.concatenate((X1, X2)) #将数据级联

print(X) #得到级联的两列数据X Y 将数据放在一起

plt.figure(figsize=(10, 8))
plt.scatter(X[:, 0], X[:, 1], marker=‘o’)
plt.show()

K-Means 聚类算法演示（k=2,3,4）

from sklearn.cluster import KMeans
for i in range(2,5):
y_pred = KMeans(n_clusters=i, random_state=9).fit_predict(X)
plt.figure(figsize=(5, 4))
plt.scatter(X[:, 0], X[:, 1], c=y_pred)
plt.show()

当 eps =0.1 不变，改变 min_samples

from sklearn.cluster import DBSCAN
from sklearn import metrics
for i in range(0,20,5):
db=DBSCAN(eps = 0.1, min_samples = i).fit(X)
y_pred =DBSCAN(eps = 0.1, min_samples = i).fit_predict(X)
plt.figure(figsize=(3, 2))
plt.scatter(X[:, 0], X[:, 1], c=y_pred)
print(“eps=0.1，并且 min_samples=”,i)
print(“同质性:”,metrics.homogeneity_score(y_pred,db.labels_))
plt.show()
print(“----------------”*2)

当 min_samples =10 不变，改变 eps

for i in range(1,5,1):
i=float(i/20)
db=DBSCAN(eps = i, min_samples = 10).fit(X)
y_pred =DBSCAN(eps = i, min_samples = 10).fit_predict(X)
plt.figure(figsize=(3, 2))
plt.scatter(X[:, 0], X[:, 1], c=y_pred)
print(“min_samples=10，并且 eps=”,i)
print(“同质性:”,metrics.homogeneity_score(y_pred,db.labels_))
plt.show()
print(“----------------”*2)

数据分析步骤解读

import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.cluster import DBSCAN
from sklearn import metrics
data = pd.read_table(r’country.txt’,sep=“\t”)
X=data[[“面积km^2”,“人口”]]
#数据进行归一化处理（属性值在 0~10000 之间）
mm = MinMaxScaler(feature_range=(0,10000))
mm_data = mm.fit_transform(X)#归一化后的数据
from sklearn.cluster import DBSCAN
from sklearn import metrics
import matplotlib.pyplot as plt
for i in range(1,5,1):
db=DBSCAN(eps = 200, min_samples = i).fit(mm_data)
y_pred =DBSCAN(eps = 200, min_samples = i).fit_predict(mm_data)
plt.figure(figsize=(3, 2))
plt.scatter(mm_data[:, 0], mm_data[:, 1], c=y_pred)
print(“eps=200，并且 min_samples=”,i)
print(“同质性:”,metrics.homogeneity_score(y_pred,db.labels_))
plt.show()
print(“----------------”*2)

聚类度量-------------------------------------------------------------

数据分析步骤解读

import pandas as pd
data = pd.read_table(r’city.txt’,sep=“,”) #[2259 rows x 2 columns]
#数据预处理经纬度单位一致不需要标准化
data=data.dropna() #[2259 rows x 2 columns] 无缺失数据

#霍普金斯统计量

from numpy.random import uniform,normal
from scipy.spatial.distance import cdist
#霍普金斯统计量计算，input:DataFrame类型的二维数据，output:float类型的霍普金斯统计量
#默认从数据集中抽样的比例为0.3
def hopkins_statistic(data:pd.DataFrame,sampling_ratio:float = 0.3) -> float:
#抽样比例超过0.1到0.5区间任意一端则用端点值代替
sampling_ratio = min(max(sampling_ratio,0.1),0.5)
n_samples = int(data.shape[0] * sampling_ratio)
sample_data = data.sample(n_samples) #原始数据抽样后剩余的数据
data = data.drop(index = sample_data.index) #,inplace = True)
#原始数据中抽取的样本与最近邻的距离之和
data_dist = cdist(data,sample_data).min(axis = 0).sum()
#人工生成的样本点，从平均分布中抽样(artificial generate samples)
ags_data = pd.DataFrame({col:uniform(data[col].min(),data[col].max(),n_samples)
for col in data})
#人工样本与最近邻的距离之和
ags_dist = cdist(data,ags_data).min(axis = 0).sum()
#计算霍普金斯统计量H
H_value = ags_dist / (data_dist + ags_dist)
return H_value
#代码实现
print(hopkins_statistic(data)) #0.9020365524471073 存在类结构

from sklearn.cluster import KMeans #这里直接导入KMeans类进行聚类
import matplotlib.pyplot as plt
import numpy as np
plt.rcParams[‘font.sans-serif’]=[‘SimHei’] #用来正常显示中文标签
plt.rcParams[‘axes.unicode_minus’]=False #用来正常显示负号
mean_distortions = []
K = range(2,10)
for k in K:
# 在此提一句，Python的Stick-learn库中所封装的K-means聚类算法，其底层代码所采用的距离度量方法默认为欧式距离。并且不可通过调用方法时的参数设定进行修改。
k_means = KMeans(n_clusters=k, random_state=0,n_init=20,max_iter=500) # #n_clusters：聚类中心的个数，n_init：初始化聚类中心的次数默认10，max_iter：迭代次数默认300；random_state=0:随机数种子
k_means.fit(data)
mean_distortions.append(sum(np.min(cdist(data, k_means.cluster_centers_, metric=‘euclidean’), axis=1))/ data.shape[0])
plt.plot(K, mean_distortions, ‘bx-’)
plt.xlabel(‘k’)
plt.ylabel(u’平均畸变程度’)
plt.title(u’用肘部法确定最佳的K值’)
plt.show()
#由图可知k为5最好

聚类质量（轮廓系数）

from sklearn import metrics
score=[]
for k in K:
# 在此提一句，Python的Stick-learn库中所封装的K-means聚类算法，其底层代码所采用的距离度量方法默认为欧式距离。并且不可通过调用方法时的参数设定进行修改。
k_means = KMeans(n_clusters=k, random_state=0,n_init=20,max_iter=500) # #n_clusters：聚类中心的个数，n_init：初始化聚类中心的次数默认10，max_iter：迭代次数默认300；random_state=0:随机数种子
k_means.fit(data)
labels = k_means.labels_
score.append(metrics.silhouette_score(data, labels, metric=‘euclidean’))
plt.plot(K, score, ‘bx-’)
plt.xlabel(‘k’)
plt.ylabel(u’轮廓系数’)
plt.title(u’轮廓系数变化图’)
plt.show()
#由图可知k为5最好

################################实验六离群点的检测方法##################################

1.利用基于对象离群因子法识别离群点

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
import math

读取数据

datas=pd.read_csv(“banana.dat”)
Class=datas[" Class"].tolist()

print(set(Class)) #分为了两个簇

寻找簇的中心点

data=datas[[‘At1’, ’ At2’]]

print(data) #[5300 rows x 2 columns]

model_kmeans=KMeans(n_clusters=2,random_state=0)
model_kmeans.fit(data)
y_pre=model_kmeans.predict(data)

print(y_pre)

centers=model_kmeans.cluster_centers_

print(centers) #找到中心点

绘制聚类后的结果图像(运行一次看看就行) 可以看出来有不少离群点

colors=[‘r’,‘c’,‘b’]
plt.figure()
for j in range(2):
index_set=np.where(y_pre==j)
cluster=data.iloc[index_set]
plt.scatter(cluster.iloc[:,0],cluster.iloc[:,1],c=colors[j],marker=‘.’)
plt.plot(centers[j][0],centers[j][1],‘o’,markerfacecolor=colors[j],markeredgecolor=‘k’,markersize=8) #画类别中心
plt.show()

定义函数计算两点之间的距离 list1：簇的中心点 list2：判断的点

def distance(list1,list2):
distance=math.sqrt((list2[0]-list1[0])**2+(list2[1]-list1[1])**2)
return distance

def OF(data,centers):
center1=centers[0].tolist()
center2=centers[1].tolist()
OF=[]
for i in range(len(data.index)):
list2=data.loc[i].tolist()
# 判断点与所有簇间距离的加权平均值
means=(distance(center1,list2)+distance(center2,list2))/2
OF.append(means)
return OF

a=OF(data,centers)

print(a)

mean=np.mean(a) #平均值Ave_OF

print(mean)

std=np.std(a) #标准差Dev_OF

print(std)

li=[]

求OF1§≥Ave_OF+β ∗ Dev_OF(1≤β≤2) 的点（即离群点）

for i in range(len(a)):
if a[i]>=mean+std*1.285:
li.append(i)

找出非离群点

for i in range(len(li)):
data=data.drop([li[i]])
data.reset_index(drop=True,inplace=True) #重新设置索引，将原来的索引作为新的一列并入DataFrame，在原DataFrame上改动

print(data) #[4743 rows x 2 columns]

用去除利群点后的数据K-means聚类，绘制图像，看结果如何

model_kmeans=KMeans(n_clusters=2,random_state=0)
model_kmeans.fit(data)
y_pre=model_kmeans.predict(data)
centers=model_kmeans.cluster_centers_

图像堪称完美

################################补充决策树算法##################################
#决策树---------------------------------------------------------------
实现步骤：
读取数据：离散型数值数据调用Sklearn库
离散型字符串数据独热编码调用Sklearn库

Sklearn库使用的基本框架

from sklearn import tree
X = [[0, 0], [1, 1]]
Y = [“红”, “黑”]
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X, Y)
clf.predict([[2., 2.]])
clf.predict_proba([[2., 2.]])