【Python算法】时间序列预处理1.时间序列的预处理　　拿到一个观察值序列后，首先要对它的纯随机性和平稳性进行检验，这两个重要的检验被称为序列的预处理。根据检验结果可以将序列分为不同的类型，对不同类型的序列会采取不同的分析方法。　　对于纯随机序列（又称为白噪声序列），序列的各项之间没有任何相关关系，序列在进行完全无序的随机波动，可以终止对该序列的分析。白噪声序列是没有信息可提取的平稳序列。　　对于平稳非白噪声序列，它的均值和方差是常数，现已有一套非常成熟的平稳序列的建模方法。通常是建立一个线性模型来拟合该序列的发展，借此提取该序列的有用信息。ARMA 模型是最常用的平稳序列拟合模型。　　对于非平稳序列，由于它的均值和方差不稳定，处理方法一般是将其转变为平稳序列，这样就可以应用有关平稳时间序列的分析方法，如建立ARMA模型来进行相应的研究。如果一个时间序列经差分运算后具有平稳性，则该序列为差分平稳序列，可以使用ARIMA模型进行分析。 　　2.平稳性检验　　2.平稳性的检验　　对序列的平稳性的检验有两种检验方法：　　一种是根据时序图和自相关图的特征做出判断的图检验，该方法操作简单、应用广泛，缺点是带有主观性；　　另一种是构造检验统计量进行检验的方法，目前最常用的方法是单位根检验。　　① 时序图检验 根据平稳时间序列的均值和方差都为常数的性质，平稳序列的时序图显示该序列值始终在一个常数附近随机波动，而且被动的范围有界；如果有明显的趋势性或者周期性，那它通常不是平稳序列。　　② 自相关图检验 平稳序列具有短期相关性，这个性质表明对平稳序列而言通常只有近期的序列值对现时值的影响比较明显，间隔越远的过去值对现时值的影响越小。随着延迟期数k的增加，平稳序列的自相关系数pk（延迟 k 期）会比较快的衰减趋向于零，并在零附近随机波动，而非平稳序列的自相关系数衰减的速度比较慢，这就是利用自相关图进行平稳性检验的标准。　　③ 单位根检验单位根检验是指检验序列中是否存在单位根，如果存在单位根就是非平稳时间序列。3.纯随机性检验　　如果一个序列是纯随机序列，那么它的序列值之间应该没有任何关系，即满足y(k) = 0, k ≠ 0，这是一种理论上才会出现的理想状态，实际上纯随机序列的样本自相关系数不会绝对为零，但是很接近零，并在零附近随机波动。　　纯随机性检验，一般是构造检验统计量来检验序列的纯随机性，常用的检验统计量有Q统计量、LB统计量，由样本各延迟期数的自相关系数可以计算得到检验统计量，然后计算出对应的p值，如果p值显著大于显著性水平a，则表示该序列不能拒绝纯随机的原假设，可以停止对该序列的分析。

【Python算法】协同过滤算法——基于物品的协同过滤算法推荐算法背景：        互联网的迅猛发展将人类带入了信息社会和网络经济时代，信息化影响到了生活的方方面面。但是随着互联网产业的扩大，为用户提供更多选的同时也带来了筛选与推荐的难题。于是便提出了推荐算法帮助用户快速找到自己喜爱的东西。例如京东、淘宝、美团等，在用户购买物品后，均会给用户推荐他们可能喜欢的物品，不仅免去了用户不断查找类似物品的烦恼，而且也使得用户可以货比多家，最终找到自己物美价廉的商品，而相关的网站平台也可以提升自己的销量。电影推荐也是比较常见的，例如用户观看了阿甘正传，可能推荐给用户肖申克的救赎、当幸福来敲门等，推荐相关的应用数不胜数，但其核心就是相关的推荐算法的组合。目前有关个性化推荐算法主要分为三大类：1.基于协同过滤的推荐；2.基于内容过滤的推荐；3.社会化推荐。本文主要讨论基于协同过滤的推荐，而该算法也可以划分为两类：这里主要介绍基于物品的协同过滤算法（ItemCF）：内容过滤根据信息资源与用户兴趣的相似性来推荐商品，通过计算用户兴趣模型和商品特征向量之间的向量相似性，主动将相似度高的商品发送给该模型的客户。由于每个客户都独立操作，拥有独立的特征向量，不需要考虑别的用户的兴趣，不存在评价级别多少的问题，能推荐新的项目或者是冷门的项目。这些优点使得基于内容过滤的推荐系统不受冷启动和稀疏问题的影响实验工具1.python　　Python是一种计算机程序设计语言。是一种动态的、面向对象的脚本语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。Python已经成为最受欢迎的程序设计语言之一。自从2004年以后，python的使用率呈线性增长。2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。　　由于Python语言的简洁性、易读性以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用Python语言讲授。　　众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。jupyter        Jupyter Notebook（此前被称为 IPython notebook）是一个交互式笔记本，支持运行 40 多种编程语言。Jupyter Notebook 的本质是一个 Web 应用程序，便于创建和共享文学化程序文档，支持实时代码，数学方程，可视化和 markdown。 用途包括：数据清理和转换，数值模拟，统计建模，机器学习等等基于物品的推荐算法以及流程例如前面背景中介绍的，用户喜欢看阿甘正传，且给了高评分后，那么系统将会寻找与阿甘正传类似的电影推荐给用户。算法流程构建用户–>物品的倒排；构建物品与物品的同现矩阵；计算物品之间的相似度，即计算相似矩阵；根据用户的历史记录，给用户推荐物品；算法流程1构建用户–>物品的倒排如下表，行表示用户，列表示物品，1表示用户喜欢该物品用户\物品abcdeA11B1111C1D111E11例如python构建的数据格式如下 { 'A': {'a': '1', 'b': '1', 'd': '1'},  'B': {'c': '1', 'b': '1', 'e': '1'},  'C': {'c': '1', 'd': '1'},  'D': {'c': '1', 'b': '1', 'd': '1'}, 'E': {'a': '1', 'd': '1'} }算法流程2构建物品与物品的同现矩阵共现矩阵C表示同时喜欢两个物品的用户数，是根据用户物品倒排表计算出来的。如根据上面的用户物品倒排表可以计算出如下的共现矩阵C：物品\物品abcdeA12B1221C221D222E11算法流程3计算物品之间的相似度，即计算相似矩阵其中两个物品之间的相似度如何计算？设|N(i)|表示喜欢物品i的用户数，|N(i)⋂N(j)|表示同时喜欢物品i，j的用户数，则物品i与物品j的相似度为：(1)式有一个问题，当物品j是一个很热门的商品时，人人都喜欢，那么wij就会很接近于1，即(1)式会让很多物品都和热门商品有一个很大的相似度，所以可以改进一下公式：算法流程2中的共现矩阵C其实就是式(2)的分子，矩阵N（用于计算分母）表示喜欢某物品的用户数（是总的用户数），则(2)式中的分母便很容易求解出来了。矩阵N如下所示：物品abcde用户数23341利用式（2）便能计算物品之间的余弦相似矩阵如下：物品\物品abcdea0.410.71b0.410.670.580.58c0.670.580.58d0.710.580.58e0.580.58算法流程4根据用户的历史记录，给用户推荐物品；最终推荐的是什么物品，是由预测兴趣度决定的。物品j预测兴趣度=用户喜欢的物品i的兴趣度×物品i和物品j的相似度例如：A用户喜欢a，b，d ，兴趣度分别为1,1,1推荐c的预测兴趣度=1X0.67+1X0.58=1.25推荐e的预测兴趣度=1X0.58=0.58python实现算法数据描述该数据为用户，兴趣度，物品    #用户，兴趣度，物品     uid_score_bid = ['A,1,a', 'A,1,b', 'A,1,d', 'B,1,b', 'B,1,c', 'B,1,e', 'C,1,c', 'C,1,d', 'D,1,b', 'D,1,c', 'D,1,d',                      'E,1,a', 'E,1,d']  2.python实现物品推荐    # -*- coding: UTF-8 -*-     from math import sqrt     import operator     # 用户，兴趣度，物品     uid_score_bid = ['A,1,a', 'A,1,b', 'A,1,d', 'B,1,b', 'B,1,c', 'B,1,e', 'C,1,c', 'C,1,d', 'D,1,b', 'D,1,c', 'D,1,d',                      'E,1,a', 'E,1,d']     # 1.构建用户-->物品的倒排     def loadData(files):         data = {}         for line in files:             user,score,item = line.split(",")             data.setdefault(user,{})             data[user][item] = score         print("----1.用户：物品的倒排----")         print(data)         return data     # 2.1 构造物品-->物品的共现矩阵     # 2.2 计算物品与物品的相似矩阵     def similarity(data):         # 2.1 构造物品：物品的共现矩阵         N = {}  # 喜欢物品i的总人数         C = {}  # 喜欢物品i也喜欢物品j的人数         for user,item in data.items():             for i,score in item.items():                 N.setdefault(i,0)                 N[i] += 1                 C.setdefault(i,{})                 for j,scores in item.items():                     if j not in i:                         C[i].setdefault(j,0)                         C[i][j] += 1         print("---2.构造的共现矩阵---")         print ('N:',N)         print ('C',C)         # 2.2 计算物品与物品的相似矩阵         W = {}         for i,item in C.items():             W.setdefault(i,{})             for j,item2 in item.items():                 W[i].setdefault(j,0)                 W[i][j] = C[i][j]/sqrt(N[i]*N[j])         print("---3.构造的相似矩阵---")         print(W)         return W     # 3.根据用户的历史记录，给用户推荐物品     def recommandList(data,W,user,k=3,N=10):         rank = {}         for i,score in data[user].items():  # 获得用户user历史记录，如A用户的历史记录为{'a': '1', 'b': '1', 'd': '1'}             for j,w in sorted(W[i].items(),key=operator.itemgetter(1),reverse=True)[0:k]:  # 获得与物品i相似的k个物品                 if j not in data[user].keys():  # 该相似的物品不在用户user的记录里                     rank.setdefault(j,0)                     rank[j] += float(score) * w         print("---4.推荐----")         print(sorted(rank.items(),key=operator.itemgetter(1),reverse=True)[0:N])         return sorted(rank.items(),key=operator.itemgetter(1),reverse=True)[0:N]     if __name__ == '__main__':         # 用户，兴趣度，物品         uid_score_bid = ['A,1,a', 'A,1,b', 'A,1,d', 'B,1,b', 'B,1,c', 'B,1,e', 'C,1,c', 'C,1,d', 'D,1,b', 'D,1,c', 'D,1,d',                          'E,1,a', 'E,1,d']         data = loadData(uid_score_bid)  # 获得数据         W = similarity(data)  # 计算物品相似矩阵         recommandList(data, W, 'A', 3, 10)  #推荐运行结果如下图：电影推荐应用案例1.电影数据描述    data = {'Lisa Rose': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.5,                           'Just My Luck': 3.0, 'Superman Returns': 3.5, 'You, Me and Dupree': 2.5,                           'The Night Listener': 3.0},             'Gene Seymour': {'Lady in the Water': 3.0, 'Snakes on a Plane': 3.5,                              'Just My Luck': 1.5, 'Superman Returns': 5.0, 'The Night Listener': 3.0,                              'You, Me and Dupree': 3.5},             'Michael Phillips': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.0,                                  'Superman Returns': 3.5, 'The Night Listener': 4.0},             'Claudia Puig': {'Snakes on a Plane': 3.5, 'Just My Luck': 3.0,                              'The Night Listener': 4.5, 'Superman Returns': 4.0,                              'You, Me and Dupree': 2.5},             'Mick LaSalle': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0,                              'Just My Luck': 2.0, 'Superman Returns': 3.0, 'The Night Listener': 3.0,                              'You, Me and Dupree': 2.0},             'Jack Matthews': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0,                               'The Night Listener': 3.0, 'Superman Returns': 5.0, 'You, Me and Dupree': 3.5},             'Toby': {'Snakes on a Plane': 4.5, 'You, Me and Dupree': 1.0, 'Superman Returns': 4.0}             }2.推荐推荐过程和上面的代码过程一样，仅不用构造倒排数据demo.py:    # -*- coding: UTF-8 -*-     from math import sqrt     import operator     data = {'Lisa Rose': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.5,                               'Just My Luck': 3.0, 'Superman Returns': 3.5, 'You, Me and Dupree': 2.5,                               'The Night Listener': 3.0},                 'Gene Seymour': {'Lady in the Water': 3.0, 'Snakes on a Plane': 3.5,                                  'Just My Luck': 1.5, 'Superman Returns': 5.0, 'The Night Listener': 3.0,                                  'You, Me and Dupree': 3.5},                 'Michael Phillips': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.0,                                      'Superman Returns': 3.5, 'The Night Listener': 4.0},                 'Claudia Puig': {'Snakes on a Plane': 3.5, 'Just My Luck': 3.0,                                  'The Night Listener': 4.5, 'Superman Returns': 4.0,                                  'You, Me and Dupree': 2.5},                 'Mick LaSalle': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0,                                  'Just My Luck': 2.0, 'Superman Returns': 3.0, 'The Night Listener': 3.0,                                  'You, Me and Dupree': 2.0},                 'Jack Matthews': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0,                                   'The Night Listener': 3.0, 'Superman Returns': 5.0, 'You, Me and Dupree': 3.5},                 'Toby': {'Snakes on a Plane': 4.5, 'You, Me and Dupree': 1.0, 'Superman Returns': 4.0}                 }     # 1.构建用户-->物品的倒排（此推荐无需使用）     def loadData(files):         data = {}         for line in files:             user,score,item = line.split(",")             data.setdefault(user,{})             data[user][item] = score         print("----1.用户：物品的倒排----")         print(data)         return data     # 2.1 构造物品-->物品的共现矩阵     # 2.2 计算物品与物品的相似矩阵     def similarity(data):         # 2.1 构造物品：物品的共现矩阵         N = {}  # 喜欢物品i的总人数         C = {}  # 喜欢物品i也喜欢物品j的人数         for user,item in data.items():             for i,score in item.items():                 N.setdefault(i,0)                 N[i] += 1                 C.setdefault(i,{})                 for j,scores in item.items():                     if j not in i:                         C[i].setdefault(j,0)                         C[i][j] += 1         print("---2.构造的共现矩阵---")         print ('N:',N)         print ('C',C)         # 2.2 计算物品与物品的相似矩阵         W = {}         for i,item in C.items():             W.setdefault(i,{})             for j,item2 in item.items():                 W[i].setdefault(j,0)                 W[i][j] = C[i][j]/sqrt(N[i]*N[j])         print("---3.计算的相似矩阵---")         print(W)         return W     # 3.根据用户的历史记录，给用户推荐物品     def recommandList(data,W,user,k=3,N=10):         rank = {}         for i,score in data[user].items():  # 获得用户user历史记录，如A用户的历史记录为{'a': '1', 'b': '1', 'd': '1'}             for j,w in sorted(W[i].items(),key=operator.itemgetter(1),reverse=True)[0:k]:  # 获得与物品i相似的k个物品                 if j not in data[user].keys():  # 该相似的物品不在用户user的记录里                     rank.setdefault(j,0)                     rank[j] += float(score) * w         print("---3.推荐----")         print(sorted(rank.items(),key=operator.itemgetter(1),reverse=True)[0:N])         return sorted(rank.items(),key=operator.itemgetter(1),reverse=True)[0:N]     if __name__ == '__main__':         print("---1.构造数据---")         W = similarity(data)  # 计算物品相似矩阵         recommandList(data, W, 'Toby', 10, 10)  #推荐推荐结果如下图所示：

【Python算法】关联规则算法——Apriori算法1.关联规则　　所谓关联，反映的是一个事件和其他事件之间依赖或关联的知识。当查找某些东西的时候，可以发现有两个或两个以上都有关联的含义。第一个是相关性relevance，第二个是关联性association，两者都可以用来描述事件之间的关联程度。2.Apriori算法简介　　Apriori算法是经典的挖掘频繁项集和关联规则的数据挖掘算法。其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集，它使用一种称为逐层搜索的迭代方法，其中k项集用于探索(k+1)项集。首先，通过扫描数据库，累计每个项的计数，并收集满足最小支持度的项，找出频繁1项集的集合。该集合记为L1。然后，使用L1找出频繁2项集的集合L2，使用L2找出L3，如此下去，直到不能再找到频繁 k 项集。每找出一个Lk需要一次数据库的完整扫描。Apriori算法使用频繁项集的先验性质来压缩搜索空间。在Apriori算法中，有以下几个关键概念：　　(1)项与项集：设itemset={item1, item_2, …, item_m}是所有项的集合，其中，item_k(k=1,2,…,m)成为项。项的集合称为项集（itemset），包含k个项的项集称为k项集(k-itemset)；　　(2)事务与事务集：一个事务T是一个项集，它是itemset的一个子集，每个事务均与一个唯一标识符Tid相联系。不同的事务一起组成了事务集D，它构成了关联规则发现的事务数据库；　　(3)关联规则：关联规则是形如A=>B的蕴涵式，其中A、B均为 itemset的子集且均不为空集，而A交B为空；　　支持度(support)：关联规则的支持度定义如下：support(A⇒ B) = P(AUB)　　其中P(AUB) 表示事务包含集合A和B的并（即包含A和B中的每个项）的概率。注意与P（A or B）的区别，后者表示事务包含A或B的概率。　　 (1) 置信度（confidence）：关联规则的置信度定义如下：confidence(A\Rightarrow B)=P(B|A)=\frac {support(A\bigcup B)}{support(A)}=\frac{support \\_count(A\bigcup B)}{support\\_count(A)}       (2) 项集的出现频度（support count）：包含项集的事务数，简称为项集的频度、支持度计数或计数；　　(3) 频繁项集（frequent itemset）：如果项集 1 的相对支持度满足事先定义好的最小支持度阈值（即 1 的出现频度大于相应的最小出现频度（支持度计数）阈值），则 1 是频繁项集；　　(4) 强关联规则：满足最小支持度和最小置信度的关联规则，即待挖掘的关联规则。3.挖掘项集相关定义　　连接步骤：　　频繁（k-1）项集Lk-1的自身连接产生候选 k 项集Ck。　　Apriori算法假定项集中的项按照字典序排序。如果Lk-1中某两个的元素（项集）itemset1和itemset2的前（k-2）个项是相同的，则称itemset1和itemset2是可连接的。所以 itemset1与itemset2连接产生的结果项集是{itemset1[1], itemset1[2], …, itemset1[k-1], itemset2[k-1]}。连接步骤包含在create_Ck函数中。　　剪枝策略 :　　由于存在先验性质：任何非频繁的（k-1）项集都不是频繁k项集的子集。因此，如果一个候选k项集Ck的（k-1）项子集不在Lk-1中，则该候选也不可能是频繁的，从而可以从Ck中删除，获得压缩后的Ck。（is_apriori）函数用于判断是否满足先验性质，（create_Ck）函数中包含剪枝步骤，即若不满足先验性质，剪枝。　　删除策略 :　　基于压缩后的Ck，扫描所有事务，对Ck中的每个项进行计数，然后删除不满足最小支持度的项，从而获得频繁k项集。删除策略包含在下文代码中的（generate_Lk_by_Ck）函数中。　　每个项都是候选1项集的集合C1的成员。算法扫描所有的事务，获得每个项，生成C1。然后对每个项进行计数。然后根据最小支持度从C1中删除不满足的项，从而获得频繁1项集L1。 对L1的自身连接生成的集合执行剪枝策略产生候选2项集的集合C2，然后，扫描所有事务，对C2中每个项进行计数。同样的，根据最小支持度从C2中删除不满足的项，从而获得频繁2项集L2。　　对L2的自身连接生成的集合执行剪枝策略产生候选3项集的集合C3，然后，扫描所有事务，对C3每个项进行计数。同样的，根据最小支持度从C3 中删除不满足的项，从而获得频繁3项集L3。　　以此类推，对Lk-1的自身连接生成的集合执行剪枝策略产生候选k项集Ck，然后扫描所有事务，对Ck中的每个项进行计数。然后根据最小支持度从Ck中删除不满足的项，从而获得频繁k项集。　　由频繁项集产生关联规则一旦找出了频繁项集，就可以直接由它们产生强关联规则。产生步骤如下：对于每个频繁项集itemset，产生itemset的所有非空子集（这些非空子集一定是频繁项集）； 对于 itemset 的每个非空子集 s，如果则输出s ⇒ (l−s) ，其中min_conf是最小置信度阈值。关联分析　　关联分析是一种在大规模数据集中寻找有趣关系的任务。 这些关系可以有两种形式:　　(1) 频繁项集（frequent item sets）: 经常出现在一块的物品的集合。　　(2) 关联规则（associational rules）: 暗示两种物品之间可能存在很强的关系。相关术语　　关联分析（关联规则学习): 从大规模数据集中寻找物品间的隐含关系被称作关联分析(associati analysis) 或者关联规则学习（association rule learning） 。 下面是用一个杂货店 例子来说明这两个概念，如图1所示:　　频繁项集: {葡萄酒, 尿布, 豆奶} 就是一个频繁项集的例子。　　关联规则: 尿布 -> 葡萄酒 就是一个关联规则。这意味着如果顾客买了尿布，那么他很可能会买葡萄酒。　　那么频繁的定义是什么呢？怎么样才算频繁呢？度量它们的方法有很多种，这里我们来简单的介绍下支持度和可信度。　　支持度: 数据集中包含该项集的记录所占的比例。例如上图中，{豆奶} 的支持度为 4/5。{豆奶, 尿布} 的支持度为 3/5。可信度: 针对一条诸如 {尿布} -> {葡萄酒} 这样具体的关联规则来定义的。这条规则的 可信度 被定义为 支持度({尿布, 葡萄酒})/支持度({尿布})，从图中可以看出 支持度({尿布, 葡萄酒}) = 3/5，支持度({尿布}) = 4/5，所以 {尿布} -> {葡萄酒} 的可信度 = 3/5 / 4/5 = 3/4 = 0.75。　　支持度和可信度是用来量化关联分析是否成功的一个方法。 假设想找到支持度大于0.8的所有项集，应该如何去做呢？一个办法是生成一个物品所有可能组合的清单，然后对每一种组合统计它出现的频繁程度，但是当物品成千上万时，上述做法就非常非常慢了。我们需要详细分析下这种情况并讨论下Apriori原理，该原理会减少关联规则学习时所需的计算量。3.Apriori原理　　假设我们一共有4个商品: 商品0, 商品1, 商品2, 商品3。 所有可能的情况如图2所示:　　如果我们计算所有组合的支持度，也需要计算15次。即2^N-1=2^4-1=15。随着物品的增加，计算的次数呈指数的形式增长 ...　　为了降低计算次数和时间，研究人员发现了一种所谓的Apriori原理，即某个项集是频繁的，那么它的所有子集也是频繁的。例如，如果{0, 1}是频繁的，那么{0}, {1}也是频繁的。该原理直观上没有什么帮助，但是如果反过来看就有用了，也就是说如果一个项集是非频繁项集，那么它的所有超集也是非频繁项集，如图3所示:　　在图3中我们可以看到，已知蓝色部分{2,3}是非频繁项集，那么利用上面的知识，我们就可以知道{0,2,3}{1,2,3}{0,1,2,3}都是非频繁的。也就是说计算出{2,3}的支持度，知道它是非频繁的之后，就不需要再计算{0,2,3}{1,2,3}{0,1,2,3}的支持度，因为我们知道这些集合不会满足我们的要求。使用该原理就可以避免项集数目的指数增长，从而在合理的时间内计算出频繁项集。操作系统　　操作机： Linux_Ubuntu　　　操作机默认用户：root步骤1：Apriori算法分块讲解　　1.1 首先了解一下算法中导入的模块及其简介。其中，sys是system的缩写，用来获取操作系统和编译器的一些配置，设置及操作。如判断文件和文件夹是否存在，创建文件文件夹，获取系统版本之类的操作。itertools库，迭代器（生成器）在Python中是一种很常用也很好用的数据结构，比起列表(list)来说，迭代器最大的优势就是延迟计算，按需使用，从而提高开发体验和运行效率。collections是集合模块，optparse模块可以用用来定义option参数。import sys   from itertools import chain, combinations from collections import defaultdict from optparse import OptionParser　　1.2 主函数的部分，其中定义了三个程序功能选项，-f是使用数据文件，-s用来设置最小支持度(默认是0.15)，-c用来设置最小可信度(默认是0.6)。if __name__ == "__main__":     optparser = OptionParser()  #创建一个OptionParser对象     optparser.add_option('-f', '--inputFile',                          dest='input',                          help='filename containing csv',                          default=None)  #添加待定义命令行参数，及其帮助文档。     optparser.add_option('-s', '--minSupport',                          dest='minS',                          help='minimum support value',                          default=0.15,                          type='float') #添加待定义命令行参数，及其帮助文档。     optparser.add_option('-c', '--minConfidence',                          dest='minC',                          help='minimum confidence value',                          default=0.6,                          type='float') #添加待定义命令行参数，及其帮助文档。     (options, args) = optparser.parse_args()  #接收参数     inFile = None       if options.input is None:  #文件内容为空的情况             inFile = sys.stdin     elif options.input is not None:  #文件内容不为空的情况             inFile = dataFromFile(options.input)  #把文件内容读到inFile中     else:             print ('No dataset filename specified, system with exit\n')             sys.exit('System will exit')     minSupport = options.minS   #设置最小支持度     minConfidence = options.minC   #设置最小可信度     items, rules = runApriori(inFile, minSupport, minConfidence)  #运行算法，其中三个参数分别是从文件中读出的数据、最小支持度和最小可信度     printResults(items, rules)  #调用结果显示函数步骤1：Apriori算法分块讲解　　1.1 首先了解一下算法中导入的模块及其简介。其中，sys是system的缩写，用来获取操作系统和编译器的一些配置，设置及操作。如判断文件和文件夹是否存在，创建文件文件夹，获取系统版本之类的操作。itertools库，迭代器（生成器）在Python中是一种很常用也很好用的数据结构，比起列表(list)来说，迭代器最大的优势就是延迟计算，按需使用，从而提高开发体验和运行效率。collections是集合模块，optparse模块可以用用来定义option参数。import sys   from itertools import chain, combinations from collections import defaultdict from optparse import OptionParser　　1.2 主函数的部分，其中定义了三个程序功能选项，-f是使用数据文件，-s用来设置最小支持度(默认是0.15)，-c用来设置最小可信度(默认是0.6)。if __name__ == "__main__":     optparser = OptionParser()  #创建一个OptionParser对象     optparser.add_option('-f', '--inputFile',                          dest='input',                          help='filename containing csv',                          default=None)  #添加待定义命令行参数，及其帮助文档。     optparser.add_option('-s', '--minSupport',                          dest='minS',                          help='minimum support value',                          default=0.15,                          type='float') #添加待定义命令行参数，及其帮助文档。     optparser.add_option('-c', '--minConfidence',                          dest='minC',                          help='minimum confidence value',                          default=0.6,                          type='float') #添加待定义命令行参数，及其帮助文档。     (options, args) = optparser.parse_args()  #接收参数     inFile = None       if options.input is None:  #文件内容为空的情况             inFile = sys.stdin     elif options.input is not None:  #文件内容不为空的情况             inFile = dataFromFile(options.input)  #把文件内容读到inFile中     else:             print ('No dataset filename specified, system with exit\n')             sys.exit('System will exit')     minSupport = options.minS   #设置最小支持度     minConfidence = options.minC   #设置最小可信度     items, rules = runApriori(inFile, minSupport, minConfidence)  #运行算法，其中三个参数分别是从文件中读出的数据、最小支持度和最小可信度     printResults(items, rules)  #调用结果显示函数　　1.3 Apriori函数通过计算频繁项集计算支持度，再通过支持度计算可信度，从而空值阈值。代码如下:def runApriori(data_iter, minSupport, minConfidence):     """     run the apriori algorithm. data_iter is a record iterator     Return both:      - items (tuple, support)      - rules ((pretuple, posttuple), confidence)     """     itemSet, transactionList = getItemSetTransactionList(data_iter)   #itemSet是一个集合，用来保存都有哪些商品(集合不会出现重复，所以这里使用集合)，transactionList用来保存商品的组合     freqSet = defaultdict(int)   #保存出现频率     largeSet = dict()   #保存所有的商品组合     # 存储的全局字典(key=n-itemSets,value=support)，满足minSupport     assocRules = dict()    #存储关联规则的字典     # Dictionary which stores Association Rules     oneCSet = returnItemsWithMinSupport(itemSet,                                         transactionList,                                         minSupport,                                         freqSet)  #得到满足最小支持度的集合     currentLSet = oneCSet     k = 2     while(currentLSet != set([])):  #循环用来获得largeSet字典，分别对应商品数量为1-n的商品组合         largeSet[k-1] = currentLSet         currentLSet = joinSet(currentLSet, k)         currentCSet = returnItemsWithMinSupport(currentLSet,                                                 transactionList,                                                 minSupport,                                                 freqSet)         currentLSet = currentCSet         k = k + 1     def getSupport(item):  #计算支持度             """local function which Returns the support of an item"""             return float(freqSet[item])/len(transactionList)     toRetItems = []     for key, value in largeSet.items():         toRetItems.extend([(tuple(item), getSupport(item))                            for item in value])     toRetRules = []     for key, value in list(largeSet.items())[1:]:         for item in value:             _subsets = map(frozenset, [x for x in subsets(item)])             for element in _subsets:                 remain = item.difference(element)                 if len(remain) > 0:                     confidence = getSupport(item)/getSupport(element)                     if confidence >= minConfidence:                         toRetRules.append(((tuple(element), tuple(remain)),                                            confidence))     return toRetItems, toRetRules步骤2：应用Apriori算法进行关联规则运算　　2.1 打开终端(该系统镜像默认是root用户)　　2.2 这一步的目的是把算法保存为py文件:在当前路径下也就是桌面上创建一个apriori.py文件，并用vim打开。vim进入后，按键盘上的i键进入输入模式，将教程最后面给出的代码复制进去，然后按Esc键退出输入模式后，输入:wq保存退出。　　输入下列命令:touch apriori.pyvim apriori.py　　按键盘上的i键进入输入模式后，将代码复制进该文件后按键盘Esc键退出输入模式后，输入:wq保存退出。　　注意在复制粘贴时，暂不支持中文。详细代码见最后附件。　　2.3 这一步是准备我们的待计算数据集:在当前路径下也就是桌面上创建一个data文件，并用vim打开。vim进入后，按键盘上的i键进入输入模式，将数据集输入进去，然后按Esc键退出输入模式后，输入:wq保存退出。　　输入下列命令:touch datavim data　　按键盘上的i键进入输入模式后，将下列数据输入进文件后按键盘Esc键退出输入模式后，输入:wq保存退出:11,12,13, 12,14, 12,13, 11,12,14, 11,13, 12,13, 11,13, 11,12,13,15, 11,12,13,　　2.4 运行程序，并计算data文件中数据的关联度。该算法将每一个商品项的支持度显示出来并且显示各商品间的可信度。在终端中输入如下命令:python3 apriori.py -f data　　该命令是指使用python3运行apriori.py，其中-f data是apriori.py程序的参数。运行结果如图9所示:　　2.5 如果将-s参数设置为0.5，-c参数设置为0.7，那么将只会计算输出支持度大于0.5商品和可信度大于0.7的商品组合。结果如图10所示:python3 apriori.py -f data -s 0.5 -c 0.7附　　完整代码如下:import sys from itertools import chain, combinations from collections import defaultdict from optparse import OptionParser def subsets(arr):     """ Returns non empty subsets of arr"""     return chain(*[combinations(arr, i + 1) for i, a in enumerate(arr)]) def returnItemsWithMinSupport(itemSet, transactionList, minSupport, freqSet):         """calculates the support for items in the itemSet and returns a subset        of the itemSet each of whose elements satisfies the minimum support"""         _itemSet = set()         localSet = defaultdict(int)         for item in itemSet:                 for transaction in transactionList:                         if item.issubset(transaction):                                 freqSet[item] += 1                                 localSet[item] += 1         for item, count in localSet.items():                 support = float(count)/len(transactionList)                 if support >= minSupport:                         _itemSet.add(item)         return _itemSet def joinSet(itemSet, length):         """Join a set with itself and returns the n-element itemsets"""         return set([i.union(j) for i in itemSet for j in itemSet if len(i.union(j)) == length]) def getItemSetTransactionList(data_iterator):  #读出文件中的商品列表     transactionList = list()  #初始化     itemSet = set()  #初始化     for record in data_iterator:         transaction = frozenset(record)         transactionList.append(transaction)   #transaction保存商品的购买组合方式         for item in transaction:             itemSet.add(frozenset([item]))              #itemSet集合用来保存单个商品名称（无重复）     return itemSet, transactionList def runApriori(data_iter, minSupport, minConfidence):     """     run the apriori algorithm. data_iter is a record iterator     Return both:      - items (tuple, support)      - rules ((pretuple, posttuple), confidence)     """     itemSet, transactionList = getItemSetTransactionList(data_iter)   #itemSet是一个集合，用来保存都有哪些商品(集合不会出现重复，所以这里使用集合)，transactionList用来保存商品的组合     freqSet = defaultdict(int)   #保存出现频率     largeSet = dict()   #保存所有的商品组合     # 存储的全局字典(key=n-itemSets,value=support)，满足minSupport     assocRules = dict()    #存储关联规则的字典     # Dictionary which stores Association Rules     oneCSet = returnItemsWithMinSupport(itemSet,                                         transactionList,                                         minSupport,                                         freqSet)  #得到满足最小支持度的集合     currentLSet = oneCSet     k = 2     while(currentLSet != set([])):  #循环用来获得largeSet字典，分别对应商品数量为1-n的商品组合         largeSet[k-1] = currentLSet         currentLSet = joinSet(currentLSet, k)         currentCSet = returnItemsWithMinSupport(currentLSet,                                                 transactionList,                                                 minSupport,                                                 freqSet)         currentLSet = currentCSet         k = k + 1     def getSupport(item):  #计算支持度             """local function which Returns the support of an item"""             return float(freqSet[item])/len(transactionList)     toRetItems = []     for key, value in largeSet.items():         toRetItems.extend([(tuple(item), getSupport(item))                            for item in value])     toRetRules = []     for key, value in list(largeSet.items())[1:]:         for item in value:             _subsets = map(frozenset, [x for x in subsets(item)])             for element in _subsets:                 remain = item.difference(element)                 if len(remain) > 0:                     confidence = getSupport(item)/getSupport(element)                     if confidence >= minConfidence:                         toRetRules.append(((tuple(element), tuple(remain)),                                            confidence))     return toRetItems, toRetRules def printResults(items, rules):     """prints the generated itemsets sorted by support and the confidence rules sorted by confidence"""     #for item, support in sorted(items, key=lambda item, support: support):     print("\n------------------------ SUPPORT:")     for item, support in sorted(items, key=lambda items: items[1]):         print ("item: %s , %.3f" % (str(item), support))     print ("\n------------------------ RULES:")     for rule, confidence in sorted(rules, key=lambda rules: rules[1]):         pre, post = rule         print ("Rule: %s ==> %s , %.3f" % (str(pre), str(post), confidence)) def dataFromFile(fname):         """Function which reads from the file and yields a generator"""         file_iter = open(fname, 'rU')         for line in file_iter:                 line = line.strip().rstrip(',')                         # Remove trailing comma                 record = frozenset(line.split(','))                 yield record if __name__ == "__main__":     optparser = OptionParser()  #创建一个OptionParser对象     optparser.add_option('-f', '--inputFile',                          dest='input',                          help='filename containing csv',                          default=None)  #添加待定义命令行参数，及其帮助文档。     optparser.add_option('-s', '--minSupport',                          dest='minS',                          help='minimum support value',                          default=0.15,                          type='float') #添加待定义命令行参数，及其帮助文档。     optparser.add_option('-c', '--minConfidence',                          dest='minC',                          help='minimum confidence value',                          default=0.6,                          type='float') #添加待定义命令行参数，及其帮助文档。     (options, args) = optparser.parse_args()  #接收参数     inFile = None     if options.input is None:  #文件内容为空的情况             inFile = sys.stdin     elif options.input is not None:  #文件内容不为空的情况             inFile = dataFromFile(options.input)  #把文件内容读到inFile中     else:             print ('No dataset filename specified, system with exit\n')             sys.exit('System will exit')     minSupport = options.minS   #设置最小支持度     minConfidence = options.minC   #设置最小可信度     items, rules = runApriori(inFile, minSupport, minConfidence)  #运行算法，其中三个参数分别是从文件中读出的数据、最小支持度和最小可信度     printResults(items, rules)  #调用结果显示函数

由于华为云无法直接发帖，所以暂时引用博客内容链接：https://bbs.huaweicloud.com/blogs/158633

1. 安装Cython     python3 -m pip install cython2. 安装blas-devel lapack-devel python3-devel  yum install blas-devel lapack-devel python3-devel3. 安装numpy  https://pypi.org/下可以查询到当前没有arm版本，执行python3 -m pip install numpy会自动下载源码编译，但编译过程会出现如下段错误     numpy/core/src/npymath/npy_math_internal.h.src: In function 'npy_cacoshf':      numpy/core/src/npymath/npy_math_internal.h.src:482:12: internal compiler error: Segmentation fault       return @kind@@c@(x, y);  从https://pypi.org/project/numpy/#files上下载最新源码编译安装        1. wget https://files.pythonhosted.org/packages/84/1e/ff467ac56bfeaea51d4a2e72d315c1fe440b20192fea7e460f0f248acac8/numpy-1.18.2.zip         2. unzip numpy-1.18.2.zip         3. 根据https://github.com/numpy/numpy/issues/13622上的建议，修改npy_math_internal.h.src文件             --- numpy/core/src/npymath/npy_math_internal.h.src.orig 2019-11-14 12:20:01.387180922 +0000                     +++ numpy/core/src/npymath/npy_math_internal.h.src 2019-11-14 12:19:17.960646234 +0000             @@ -477,7 +477,7 @@               * #KIND = ATAN2,HYPOT,POW,FMOD,COPYSIGN#               */              #ifdef HAVE_@KIND@@C@             -NPY_INPLACE @type@ npy_@kind@@c@(@type@ x, @type@ y)             +NPY_INPLACE __attribute__((optimize("-O0"))) @type@ npy_@kind@@c@(@type@ x, @type@ y)              {                  return @kind@@c@(x, y);              }          4. cd numpy-1.18.2/          5. python3 setup.py build          6. python3 setup.py install -O1 --skip-build --root /tmp/test_numpy          7. pip list可以查看安装成功4. 安装scipy    python3 -m pip install scipy    pip list确认安装成功

在鲲鹏服务器CentOS下Python pip安装依赖sicpy时报：lapack_mkl_info:        libraries mkl_rt not found in  ['/usr/local/lib64', '/usr/local/lib', ...;      openblas_lapack_info:      libraries openblas not found in ['/usr/local/lib64', '/usr/local/lib',目前在网上基本找不到有关鲲鹏ARM 框架下的 mkl_rt资料。

Python中的所有东西都是对象。这意味着动态内存分配是Python内存管理的基础。当不再需要对象时，Python内存管理器将自动从它们中回收内存。Python是使用C编程语言实现的高级编程语言。Python内存管理器管理Python的内存分配。有一个私有heap，其中包含所有Python对象和数据结构。Python内存管理器按需管理Python堆。Python内存管理器具有特定于对象的分配器，可为int，string等特定对象分别分配内存。在此之下，原始内存分配器与操作系统的内存管理器进行交互，以确保私有堆上有空间。python 中的内存管理涉及包含所有 python 对象和数据结构的私有堆。 python 内存管理器在内部保证这个私有堆的管理。 python 内存管理器有不同的组件，这些组件处理各种动态存储管理方面，比如共享，分割，预分配或者缓存。Python内存管理器管理称为“块”的内存块。相同大小的块的集合构成了“池”。池是在Arenas上创建的，在堆= 64池上分配了256kB的内存块。如果对象被销毁，则内存管理器将用相同大小的新对象填充此空间。方法和变量在堆栈存储器中创建。每当创建方法和变量时，都会创建一个堆栈框架。只要返回方法，这些框架就会自动销毁。在堆内存中创建对象和实例变量。一旦返回变量和函数，将对垃圾对象进行垃圾回收。请务必注意，Python内存管理器不一定会将内存释放回操作系统，而是将内存返回给python解释器。Python有一个小的对象分配器，用于分配内存以供进一步使用。在长时间运行的进程中，您可能有未使用内存的增量保留。Python 的内存管理主要有三种机制：引用计数机制，垃圾回收机制和内存池机制。引用计数机制对象的内存赋值语句是语言最常见的功能了。但即使是最简单的赋值语句，也可以很有内涵。Python的赋值语句就很值得研究。a = 1整数1为一个对象。而a是一个引用。利用赋值语句，引用a指向对象1。为了探索对象在内存的存储，我们可以求助于Python的内置函数id()。它用于返回对象的身份(identity)。其实，这里所谓的身份，就是该对象的内存地址。a = 1 print(id(a))print(hex(id(a)))它们返回的是:19145624800x721de7b0分别为内存地址的十进制和十六进制表示。在Python中，整数和短小的字符，Python都会缓存这些对象，以便重复使用。当我们创建多个等于1的引用时，实际上是让所有这些引用指向同一个对象。a = 1b = 1 print(id(a))print(id(b))19145624801914562480可见a和b实际上是指向同一个对象的两个引用。由于Python缓存了整数和短字符串，因此每个对象只存有一份。比如，所有整数1的引用都指向同一对象。即使使用赋值语句，也只是创造了新的引用，而不是对象本身。长的字符串和其它对象可以有多个相同的对象，可以使用赋值语句创建出新的对象。在Python中，每个对象都有存有指向该对象的引用总数，即引用计数(reference count)。我们可以使用sys包中的getrefcount()，来查看某个对象的引用计数。需要注意的是，当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。from sys import getrefcount a = [1, 2, 3]print(getrefcount(a)) b = aprint(getrefcount(b))由于上述原因，两个getrefcount将返回2和3，而不是期望的1和2。对象引用Python的一个容器对象(container)，比如表、词典等，可以包含多个对象。实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。容器对象的引用可能构成很复杂的拓扑结构。我们可以用objgraph包来绘制其引用关系，比如:x = [1, 2, 3]y = [x, dict(key1=x)]z = [y, (x, y)] import objgraphobjgraph.show_refs([z], filename='show_refs.png')两个对象可能相互引用，从而构成所谓的引用环(reference cycle)。a = []b = [a]a.append(b)即使是一个对象，只需要自己引用自己，也能构成引用环。a = []a.append(a)print(getrefcount(a))垃圾回收机制当Python中的对象越来越多，它们将占据越来越大的内存。不过不用太担心Python的体形，它会乖巧的在适当的时候启动垃圾回收(garbage collection)，将没用的对象清除。从基本原理上，当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。比如某个新建对象，它被分配给某个引用，对象的引用计数变为1。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收。比如下面的表:a = [1, 2, 3]del adel a后，已经没有任何引用指向之前建立的[1, 2, 3]这个表。用户不可能通过任何方式接触或者动用这个对象。当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。垃圾回收时，Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python只会在特定条件下，自动启动垃圾回收。当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。我们可以通过gc模块的get_threshold()方法，查看该阈值:import gc print(gc.get_threshold())python3中返回(700, 10, 10)，后面的两个10是与分代回收相关的阈值，后面可以看到。700即是垃圾回收启动的阈值。可以通过gc中的set_threshold()方法重新设置。循环引用的回收策略上文已经举例说明循环引用计数的问题，出现循环引用后，利用上述引用计数机制无法对循环引用中的对象进行释放空间，这就是循环引用问题。 解决循环引用并释放内存（标记清除）：收集所有容器对象（循环引用只针对于容器对象，其他对象不会产生循环引用），使用双向链表（可以看作一个集合）对这些对象进行引用；针对每一个容器对象，使用变量gc_refs来记录当前对应的应用个数；对于每个容器对象，找到其正在引用的其他容器对象，并将这个被引用的容器对象引用计数减去1；检查所有容器对象的引用计数，若为0，则证明该容器对象是由于循环引用存活下来的，并对其进行销毁。如何提升查找循环引用过程的性能?由一可知，循环引用查找和销毁过程非常繁琐，要分别处理每一个容器对象，所以python考虑一种改善性能的做法，即分代回收。 首先是一个假设–如果一个对象被检测了10次还没有被销毁，就减少对其的检测频率；基于这个假设，提出一套机制，即分代回收机制。 分代回收是建立在标记清除技术基础之上的，是一种以空间换时间的操作方式。Python将内存根据对象的存活时间划分为不同的集合，每个集合称为一个代，Python将内存分为了3“代”，分别为年轻代（第0代）、中年代（第1代）、老年代（第2代），他们对应的是3个链表，它们的垃圾收集频率与对象的存活时间的增大而减小。新创建的对象都会分配在年轻代，年轻代链表的总数达到上限时，Python垃圾收集机制就会被触发，把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代去，依此类推，老年代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内。内存分配（内存池机制）Python频繁地创建和销毁一些小的对象，为了减少小对象（小于512字节）的开销，Python引入了内存池机制, 用于管理对小块内存的申请和释放，较大的对象被路由到标准C分配器。 我们可以在obmalloc.c源码中可以看到关于小内存请求的描述分配的内存空间大于 SMALL_REQUEST_THRESHOLD 将直接使用layer 1的内存分配接口进行分配。 pymalloc 把“内存池”主要抽象成用3种数据结构表示：block、pool、arenablock块指的是一个确定大小的内存块，每个块保留一个固定大小的Python对象，块的大小可以从8到512字节，并且是8的倍数（即8字节对齐）。block由pool管理，所有512字节以下的内存申请会根据申请字节的大小分配不一样的block，一个pool通常为4K（系统页大小），一个pool管理着一堆固定大小的内存块（block） obmalloc.c源代码注释：* Request in bytes                           Size of allocated block      Size class idx * ---------------------------------------------------------------- *        1-8                    8                       0 *        9-16                   16                       1 *       17-24                   24                       2 *       25-32                   32                       3 *       33-40                   40                       4 *       41-48                   48                       5 *       49-56                   56                       6 *       57-64                   64                       7 *       65-72                   72                       8 *        ...                   ...                     ... *      497-504                 504                      62 *      505-512                 512                      63Poolpool 由若干个大小相等的 block 组成，相同大小的块集合称为池。通常池的大小等于存储器页面的大小，即4Kb。 将池限制为固定大小的块有助于碎片化管理，如果对象被破坏，则内存管理器可以使用相同大小的新对象填充此空间。/* Pool for small blocks. */struct pool_header {    union { block *_padding;            uint count; } ref;          /* number of allocated blocks    */    block *freeblock;                   /* pool's free list head         */    struct pool_header *nextpool;       /* next pool of this size class  */    struct pool_header *prevpool;       /* previous pool       ""        */    uint arenaindex;                    /* index into arenas of base adr */    uint szidx;                         /* block size class index        */    uint nextoffset;                    /* bytes to virgin block         */    uint maxnextoffset;                 /* largest valid nextoffset      */};每个池都使用双向链表（nextpool和prevpool字段）将相同大小的块的池链接在一起。通过这种方式，即使跨不同的池，算法也可以轻松找到给定块大小的可用空间。 szidx字段保存size类索引，而ref.count保留已使用块的数量。 arenaindex存储创建Pool的arena的索引。每个Pool有三种状态： - used - 具有可用于存储数据的块，部分使用，既不空也不满 - full - 所有池的块目前都已分配并包含数据，当该 pool 上的一个 block 被回收时，重新将该 pool 链接在适当的 usedpools 链表中。 - empty - 没有存储数据，可以在需要时分配我们已经知道，所有相同块大小的池都链接在一起。为了有效地管理池，Python使用了一个名为usedpools的列表存储跟踪可用池的指针。在分配内存时，Pymalloc先判断是否存在要申请的大小的Pool，如果存在的话，直接从Pool中获取一个Free Block返回给应用程序，这个过程是非常迅速的。如果分配完这个Block后此Pool变为一个空Pool，则将这个Pool从链表中移除。ArenaArenas是最大的内存块，并在内存中的页面边界上对齐，页面边界是OS使用的固定长度连续内存块的边缘。在Arena内的池是一个虚拟内存页（4K），在堆上分配的256kB内存块，为64个池提供内存。arena 结构定义如下obmalloc.c：struct arena_object {    uintptr_t address;    block* pool_address;    uint nfreepools;    uint ntotalpools;    struct pool_header* freepools;    struct arena_object* nextarena;    struct arena_object* prevarena;};所有arena都使用双链表（nextarena和prevarena字段）链接，跟上面的pool类似。 ntotalpools 总共分配的 pool 数量 nfreepools 可分配的 pool 数量 freepools 字段指向可用池的链接列表Arenas的实现没有什么复杂的。可以将其视为容器列表，在需要时自动为Pool分配新内存。Python的小对象管理器不一定会将内存释放回操作系统，保留了一些已分配的内存块，以备将来进一步使用。 arena 完全释放当且仅当其中的所有池都为空时，如果长时间运行的Python进程随着时间的推移需要更多内存，但并不一定意味着您有内存泄漏。内存优化内存分析工具资源（resource）resource 模块用来查看项目当前得的固有的)内存消耗(固有内存是项目实际使用的RAM)，注意resource库只在linux系统下有效import resourceresource.getrusage(resource.RUSAGE_SELF).ru_maxrss443对象（objgraph）objgraph 是一个实用模块，可以展示当前内存中存在的对象，上文中已经展示过其用法，不再过多说明。Heapyheapy 是一个实用的，用于调试内存消耗/泄漏的工具。通常，我将objgraph和heapy搭配使用：用 heapy 查看分配对象随时间增长的差异，heapy能够显示对象持有的最大内存等；用Objgraph找backref链，尝试获取它们不能被释放的原因。Heapy的典型用法是在不同地方的代码中调用一个函数，试图为内存使用量提供大量收集线索，找到可能会引发的问题：from guppyimport hpy  def dump_heap(h, i):    """    @param h: Theheap (from hp = hpy(), h = hp.heap())    @param i: Identifierstr    """     print "Dumpingstatsat: {0}".format(i)     print 'Memoryusage: {0}(MB)'.format(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024)     print "Mostcommontypes:"    objgraph.show_most_common_types()     print "heapis:"    print "{0}".format(h)     by_refs = h.byrcs    print "byreferences: {0}".format(by_refs)    print "Morestatsfor topelement.."    print "Byclodo (class or dict owner): {0}".format(by_refs[0].byclodo)    print "Bysize: {0}".format(by_refs[0].bysize)    print "Byid: {0}".format(by_refs[0].byid)内存用量诊断工具（memory_profiler）memory_profile包最好有psutil包的支持，二者皆可以通过pip安装。pip install psutil memory_profilermemory_profiler的对性能的影响很大，所以最好将测试局限在一个较小的问题上，或者在代码成长的早期进行分析。使用的方法分两步:第一步是在源代码中用‘@profile’对需要分析的函数进行标记，第二步是调用memory_profiler模块进行分析。python -m memory_profiler test_memory.py在处理内存分配时，情况并不像CPU占有率那么直截了当，通常一个进程将内存超额分配给本地内存池并在空闲时使用会更有效率，因为一次内存分配的操作非常昂贵；另外，垃圾收集不会立即执行，所以对象被销毁后依然会存在垃圾收集池中一段时间；这些技术的后或是很难真正了解一个Python程序内部的内存使用和释放情况，因为当从进程外部观察时，某一段代码可能不会分配固定数量的内存，观察多行代码的内存占有趋势可能比只观察一行代码更有参考价值。垃圾回收优化手动垃圾回收对Python的垃圾回收进行调优的一个最简单的手段便是关闭自动回收，根据情况手动触发。调高垃圾回收阈值相比完全手动的垃圾回收，一个更温和的方法是调高垃圾回收的阈值。 调高阈值的方法能在一定程度上避免内存溢出的问题(但不能完全避免)，同时可能减少可观的垃圾回收开销。根据具体项目 的不同，甚至是程序输入的不，合适的阈值也不同。因此需要反复测试找到一个合适的阈值，这也算调高阈值这种手段 的一个缺点。避免循环引用一个可能更好的方法是使用良好的编程习惯尽可能的避免循环引用。两种常见的手段包括: 手动解循环引用和使用弱引用。查找循环引用， Python的gc模块提供了gc.set_debug接口来设置一些辅助的调试信息。如果我们调用gc.set_debug(gc.DEBUG_COLLECTABLE | gc.DEBUG_OBJECTS)则每当Python进行垃圾回收时都会将 其发现的无法到达需要回收的对象的信息打印出来。例如：gc.collect()gc.set_debug(gc.DEBUG_COLLECTABLE | gc.DEBUG_OBJECTS)test2()gc.collect() gc: collectable <T 0x7fb6cacf6090>gc: collectable <T 0x7fb6cace0fd0>gc: collectable <dict 0x7fb6cac974b0>gc: collectable <dict 0x7fb6cac97280>Slots默认情况下，自定义的对象都使用dict来存储属性（通过obj.dict__查看），而python中的dict大小一般比实际存储的元素个数要大（以此降低hash冲突概率），因此会浪费一定的空间。在新式类中使用__slots，就是告诉Python虚拟机，这种类型的对象只会用到这些属性，因此虚拟机预留足够的空间就行了，如果声明了__slots__，那么对象就不会再有__dict__属性。class Student(object):    __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称使用slots到底能带来多少内存优化呢，取决于类自身有多少属性、属性的类型，以及同时存在多少个类的实例。# -*- coding: utf-8 -*-import sysimport tracemalloc NUM_OF_ATTR =  3 #3 # 10 # 30 #90NUM_OF_INSTANCE = 10 # 10 # 100 class Slots(object):    __slots__ = ['attr%s'%i for i in range(NUM_OF_ATTR)]    def __init__(self):        value_lst = (1.0, True, [], {}, ())        for i in range(NUM_OF_ATTR):            setattr(self, 'attr%s'%i, value_lst[i % len(value_lst)])  class NoSlots(object):    def __init__(self):        value_lst = (1.0, True, [], {}, ())        for i in range(NUM_OF_ATTR):            setattr(self, 'attr%s'%i, value_lst[i % len(value_lst)]) if __name__ == '__main__':    clz = Slots if len(sys.argv) > 1 else NoSlots    tracemalloc.start()    objs = [clz() for i in range(NUM_OF_INSTANCE)]    print(tracemalloc.get_traced_memory()[0])上面的代码，主要是在每个实例的属性数目、并发存在的实例数目两个维度进行测试，并没有测试不同的属性类型。结果如下表：实例数\属性数31030901028.7%25.7%43.9%64.2%10042.7%21.6%36.5%56.7%百分比为内存优化百分比，计算公式为(b - a) / b， 其中b为没有使用__slots__时分配的内存， a为使用了__slots__时分配的内存。注意事项·         基类和子类都必须__slots__，即使基类或者子类没有属性·         >>> class Base(object):··         ...     pass·         ...·         >>> class Derived(Base):·         ...     __slots__ = ('a', )·         ...·         >>> d.__slots__·         ('a',)·         >>> getattr(d, '__dict__', 'No Dict')·         {}·         子类会继承基类的__slots__·         >>> class Base(object):··         ...     __slots__ = ('a',)·         ...·         >>> class Derived(Base):·         ...     __slots__ = ('b', )·         ...·         >>> d = Derived()·         >>> d.__slots__·         ('b',)·         >>> getattr(d, '__dict__', 'No Dict')·         'No Dict'·         >>> d.a = 1·         >>> d.c = 0·         Traceback (most recent call last):·           File "<stdin>", line 1, in <module>·         AttributeError: 'Derived' object has no attribute 'c'栈溢出在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。尾递归解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。例如斐波那契数列，在最开始的时候所有的斐波那契代码都是使用递归的方式来写的，递归有很多的缺点，执行效率低下，浪费资源，还有可能会造成栈溢出，而递归的程序的优点也是很明显的，就是结构层次很清晰，易于理解。可以使用循环的方式来取代递归，当然也可以使用尾递归的方式来实现。#encoding:utf-8 import time def Fib_recursion(num):    '''    直接使用递归法求解斐波那契数量的第num个数字    '''    if num<2:        return num    return Fib_recursion(num-1)+Fib_recursion(num-2)  def Fib_tail_recursion(num,res,temp):    '''    使用尾递归法求解斐波那契数量的第num个数字    '''    if num==0:        return res    else:        return Fib_tail_recursion(num-1, temp, res+temp)  def Fib_circle(num):    '''    直接使用循环来求解    '''    a=0    b=1    for i in range(1,num):        c=a+b        a=b        b=c    return c  if __name__ == '__main__':    num_list=[5,10,20,30,40,50]    for num in num_list:        start_time=time.time()        print Fib_recursion(num)        end_time=time.time()        print Fib_tail_recursion(num,0,1)        end_time2=time.time()        print Fib_circle(num)        end_time3=time.time()        print '正在求解的斐波那契数字下标为%s' %num        print '直接递归耗时为 ：', end_time-start_time        print '尾递归调用耗时为：', end_time2-end_time        print '直接使用循环耗时为：', end_time3-end_time2deepcopycopy模块的deepcopy可以很好的完成对象的深拷贝，一个深层拷贝会构造一个新的复合对象，然后递归地将原始对象中所找到的对象的副本 插入。当对象节点内容过于庞大或者存在循环应用的话，会导致栈内存溢出或者递归循环导致进程崩溃；实际中，由于深层复制会复制所有内容，因此可能会过多复制（例如本应该在副本之间共享的数据）。 

问题1 模型推理出现 collect2: error: ld returned 1 exit status错误具体错误如下图所示：错误原因：在建立工程时Target错误选择了ASIC，正确选择如下图所示。MDC平台对应的Target为Atlas DK。问题2 推理后无法查看结果出现错误推理时log中下图所示没有报错，但是查看结果是确出现错误，无法查看结果。错误原因及解决方案：模型推理失败，导致无法查看结果。需要仔细检查流程编排中各个节点的参数配置是否正确，以及模型转换过程中设置的参数是否正确。修改错误参数或节点后解决。问题3 Profiling过程中出现RuntimeError: Bad magic number in .pyc file模型在点击run运行时可以正常运行，但是在profiling过程中出现RuntimeError: Bad magic number in .pyc file错误。错误原因及解决方案：mindstudio安装目录下的默认python为python3，修改环境变量，将其默认python版本切换为Python2即可。问题4  查看Profiling结果时无法查看OME/AICORE数据在查看profiling结果时出现如下错误，无法查看OME/AICORE的数据。错误原因及解决方案：类似于问题2，往往是由于模型推理失败导致无法出现此错误，解决方案同问题2.问题5 模型转换报错在模型转换时出现如下错误，导致模型转换失败。错误原因及解决方案：查看工程下的convertModel.log文件，查看文件末尾的报错，分析转换失败的原因。

【Python算法】聚类分析算法——系统聚类算法1. 系统聚类算法定义　　系统聚类也称为多层次聚类，就是按照某种方法进行层次分类，直到满足某种条件为止。它分类的单位由高到低呈树状结构，且所处的位置越低，其所包含的对象就越少，但这些对 象间的共同特征就越多。该聚类方法只适合在数据量较小的时候使用，数据量过大的时候速度会非常慢。　　系统聚类算法主要将对象分成两类：　　凝聚：从上到下。首先将每个对象作为一个簇，然后合并这些原子簇为越来越大的簇，直到所有对象都在同一个簇中，或者某个终结条件被满足；　　分裂：从上到下。首先将所有对象都置于同一个簇中，然后逐渐细分为越来越小的簇，直到每个对象都自称一簇，或者达到了某个终止条件,此种方法较少用。2.操作系统　　操作机：Linux_Ubuntu　　操作机默认用户：root3.实验工具        3.1.python　　Python是一种计算机程序设计语言。是一种动态的、面向对象的脚本语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。Python已经成为最受欢迎的程序设计语言之一。自从2004年以后，python的使用率呈线性增长。2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。      由于Python语言的简洁性、易读性以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用Python语言讲授。      众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。        3.2.Numpy　　NumPy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。　　NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用，以及核心的科学计算组织如：Lawrence Livermore，NASA用其处理一些本来使用C++，Fortran或Matlab等所做的任务。        3.3.scikit-learn      scikit-learn，Python 中的机器学习，简单高效的数据挖掘和数据分析工具，可供大家使用，可在各种环境中重复使用，建立在 NumPy，SciPy 和 matplotlib 上开放源码，可商业使用 - BSD license。        3.4.Matplotlib       Matplotlib 是一个 Python 的 2D绘**，它以各种硬拷贝格式和跨平台的交互式环境生成出版质量级别的图形。通过 Matplotlib，开发者可以仅需要几行代码，便可以生成绘图，直方图，功率谱，条形图，错误图，散点图等。        3.5.pandas        Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。4. 导入numpy，matploitlib，sklearn库代码如下：import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import make_circles,make_blobs,make_moons from sklearn.cluster import KMeans,DBSCAN,AgglomerativeClustering n_samples=10005.绘制不同形态散点图代码如下：#两层圆形 circles=make_circles(n_samples=n_samples,factor=0.5,noise=0.05) #两个月牙形 moons=make_moons(n_samples=n_samples,noise=0.05) #三个团形 blobs=make_blobs(n_samples=n_samples,random_state=8,center_box=(-1,1),cluster_std=0.1) #全局随机 random_data=np.random.rand(n_samples,2),None #指定聚类颜色 colors="bgrcmyk"6. 对散点图进行分别进行无处理和系统聚类处理代码如下：data=[circles,moons,blobs,random_data] models=[("None",None), ("Agglomerative",AgglomerativeClustering(n_clusters=3,linkage="ward"))]7. 获取点的键值对并绘制在坐标图中代码如下：from sklearn.metrics import silhouette_score f=plt.figure() for inx,clt in enumerate(models):     clt_name,clt_entity=clt     for i,dataset in enumerate(data):         X,Y=dataset         if not clt_entity:             clt_res=[0 for item in range(len(X))]         else:             clt_entity.fit(X)             clt_res=clt_entity.labels_.astype(np.int)         f.add_subplot(len(models),len(data),inx*len(data)+i+1)         #plt.title(clt_name)         try:             print(clt_name,i,silhouette_score(X,clt_res))         except:             pass         [plt.scatter(X[p,0],X[p,1],color=colors[clt_res[p]]) for p in range(len(X))] plt.show()注意：结果输出会有延迟。

【Python算法】聚类分析算法——K-Means聚类算法1. K-Means聚类算法过程　　K-Means 是最常用的聚类方法之一，属于划分方法。　　(1) 从N个样本数据中随机选取 K 个对象作为初始的聚类中心；　　(2) 分别计算每个样本到各个聚类中心的距离，将对象分配到距离最近的聚类中；　　(3) 所有对象分配完成后，重新计算 K 个聚类的中心；　　(4) 与前一次计算得到的 K 个聚类中心比较，如果聚类中心发生变化，转过程（2），否则转过程（5）；　　(5) 当质心不发生变化时停止并输出聚类结果。2. K-Means聚类的主要特点　　1.需要在开始时指定类别的数量，可以凭借直觉，也可以采用交叉验证或信息论的方法；　　2.聚类的结果不是决定性的，即根据初始随机指定的几何中心不同，得到的最终聚类结果也会不同。3. K-Means聚类语法结构　　在 Python 中，Scikit-Learn 库提供了 KMeans 类，其构造函数为：sklearn.cluster.KMeans(   n_clusters=8,   init='k-means++',   n_init=10,   max_iter=300,   tol =0.0001,   precompute_distances='auto',   verbose=0,    random_state=None,    copy_x=True,   n_jobs=1,    algorithm='auto')　　其主要参数有：　　(1) n_clusters：int 型，可选，默认为（8）。最终需要形成的几何中心数目，即类别个数；　　(2) max_iter：int 型，默认为（300）。每次运行的最大迭代次数；　　(3) n_init：int 型，默认为（10）。选用不同的初始化中心进行聚类的次数。4.K-Means聚类主要属性有　　(4) cluster_centers_：[n_clusters,n_features] 大小的数组。聚类中心的坐标；　　(5) labels_：每个点的分类结果；　　(6) inertia_：float 型，样本到最近聚合中心的距离和。5.实验操作    5.1.操作系统　　操作机：Linux_Ubuntu　　操作机默认用户：root    5.2.实验工具        5.2.1.python　　Python是一种计算机程序设计语言。是一种动态的、面向对象的脚本语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。Python已经成为最受欢迎的程序设计语言之一。自从2004年以后，python的使用率呈线性增长。2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。      由于Python语言的简洁性、易读性以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用Python语言讲授。      众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。        5.2.2.Numpy　　NumPy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。　　NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用，以及核心的科学计算组织如：Lawrence Livermore，NASA用其处理一些本来使用C++，Fortran或Matlab等所做的任务。        5.2.3.scikit-learn      scikit-learn，Python 中的机器学习，简单高效的数据挖掘和数据分析工具，可供大家使用，可在各种环境中重复使用，建立在 NumPy，SciPy 和 matplotlib 上开放源码，可商业使用 - BSD license。        5.2.4.Matplotlib       Matplotlib 是一个 Python 的 2D绘**，它以各种硬拷贝格式和跨平台的交互式环境生成出版质量级别的图形。通过 Matplotlib，开发者可以仅需要几行代码，便可以生成绘图，直方图，功率谱，条形图，错误图，散点图等。        5.2.5.pandas        Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。    5.3导入所需要的库:numpy,matplotlib.pyplot,pandas代码如下:# Importing the libraries import numpy as np import matplotlib.pyplot as plt import pandas as pd    5.4.加载数据集代码如下：# Importing the dataset dataset = pd.read_csv('数据集路径.CSV') X = dataset.iloc[:, 3:5].values注意：实验中以数据集的实际地址为准。（可以自建实验数据CSV格式）    5.5.使用sklearn中的k-means方法对数据进行聚类，并对其参数选择进行评估# Using the elbow method to find the optimal number of clusters from sklearn.cluster import KMeans wcss = [] for i in range(1,11):     kmeans = KMeans(n_clusters = i, max_iter = 300, n_init = 10, init = 'k-means++', random_state = 0)     kmeans.fit(X)     wcss.append(kmeans.inertia_) plt.plot(range(1,11), wcss) plt.title('The Elbow Method') plt.xlabel('Number of Clusters') plt.ylabel('WCSS') plt.show()WCSS下降曲线如下：　　在选择参数时，选择速度转换最快的阶段与下一阶段的转折点。　　由图可知：聚类数量为5。    5.6.将k-means算法用于数据集# Applying the k-means to the mall dataset kmeans = KMeans(n_clusters = 5, max_iter = 300, n_init = 10, init = 'k-means++', random_state = 0) y_kmeans = kmeans.fit_predict(X)    5.7.可视化聚类结果# Visualizing the clusters plt.scatter(X[y_kmeans == 0, 0], X[y_kmeans == 0, 1], s = 100, c = 'red', label = 'Careful') plt.scatter(X[y_kmeans == 1, 0], X[y_kmeans == 1, 1], s = 100, c = 'blue', label = 'Standard') plt.scatter(X[y_kmeans == 2, 0], X[y_kmeans == 2, 1], s = 100, c = 'green', label = 'Target') plt.scatter(X[y_kmeans == 3, 0], X[y_kmeans == 3, 1], s = 100, c = 'cyan', label = 'Careless') plt.scatter(X[y_kmeans == 4, 0], X[y_kmeans == 4, 1], s = 100, c = 'magenta', label = 'Sensible') plt.scatter(kmeans.cluster_centers_[:, 0],  kmeans.cluster_centers_[:, 1], s = 300, c = 'yellow', label = 'Centroids') plt.title('Clusters of clients') plt.xlabel('Annual Income (k$)') plt.ylabel('Spending Score (1-100)') plt.legend() plt.show()聚类结果如下：

【Python算法】分类与预测——人工神经网络1.人工神经网络概述　　人工神经网络（Artificial Neural Networks，ANN），是一种模范动物神经网络行为特征， 进行分布式并行信息处理的算法数学模型。它以对大脑的生理研究成果为基础，依靠系统的 复杂程度，通过调整内部大量节点之间相互连接的关系，模拟大脑的某些机理与机制，从而 达到处理信息，实现一些特定的功能的目的。2.人工神经网络具有四个基本特征　　(1) 非线性：非线性关系是自然界的普遍特性，大脑的智慧就是一种非线性现象。人工 神经元处于激活或抑制两种不同的状态，这种行为在数学上表现为一种非线性关系。 具有阈值的神经元构成的网络具有更好的性能，可以提高容错性和存储容量；　　(2) 非局限性：一个神经网络通常由多个神经元广泛连接而成。一个系统的整体行为不 仅取决于单个神经元的特征，而且可能主要由单元之间的相互作用、相互连接所决 定。通过单元之间的大量连接模拟大脑的非局限性。联想记忆就是非局限性的典型 例子；　　(3) 非常定性：人工神经网络具有自适应、自组织、自学习能力。神经网络不但处理的 信息可以有各种变化，而且在处理信息的同时，非线性动力系统本身也在不断变化。 经常采用迭代过程描写动力系统；　　(4) 非凸性：一个系统的演化方向，在一定条件下将取决于某个特定的状态函数。例如 能量函数，它的极值相应用于系统比较稳定的状态。非凸性是指这种函数有多个极 值，故系统具有多个较稳定的平衡态，这将导致系统演化的多样性。3.神经元（节点）组成神经网络图例　　一个神经元由输入值，激活函数，输出值，权重组成，输入值经过激活函数变为输出值，再与权重相乘变为下一个神经元的输入值。由这样的单位组成的网络就是神经网络，　　　　在实际生活中我们给更多的使用BP神经网络，即反向传播神经网络。4.BP神经网络的建模步骤       在反向传播算法中我们涉及到了求梯度的问题，但是求导运算对于计算机来说计算机太过复杂，于是诞生了牛顿法、拟牛顿法、梯度下降法等方式来帮助电脑计算梯度，在实际生活中我们常用5.梯度下降法　　梯度类似于微分，微分是针对单变量，而梯度是针对向量。　　因为直接获得最优解的计算量过大，所以通过均方误差的分析，采用迭代的方式来一步一步获得局部最优解，这就是梯度下降法。　　梯度下降法通过电脑擅长的方式——迭代，极大的减少了求梯度的计算量，但是对于一些较为复杂的函数而言，梯度下降法获得的更多是局部最优解而不是全局最优解。其中α是学习率，由右图我们可以看出，蓝方获得了更优的解，而红方停在了局部最优解。　　由此可见，使局部最优解接近全局最优解的方式便是调节学习率。　　红点和蓝点实际上就代表了反向传播算法，下山的路径其实就代表着算法中一直在寻找的参数最优解，山上当前点的最陡峭的方向实际上就是代价函数在这一点的梯度方向，场景中观测最陡峭方向所用的工具就是微分。在下一步要走多长就是由我们算法中的学习率α所定义。　　梯度下降法本身具有弹性，可以容忍不完善的数据，如果我们不能完美地描述函数，或者我们意外的走错了一步，都不至于前功尽弃。　　其中误差计算通常为均方误差，即（目标值 – 实际值）的平方，多采用均方误差的原因有以下几点：　　1. 使用误差的平方，我们可以很容易使用代数计算出梯度下降的斜率。　　2. 误差函数平滑且连续，这使梯度下降法很好的发挥了作用——没有发生间断，也没有发生跳跃。　　3. 越接近最小值，梯度就越小，这意味着，如果我们使用这个函数调节步长，超调的风险就会变得较小。　　从结构上讲，BP网络具有输入层、隐藏层和输出层；从本质上讲，BP算法就是以均方误差为目标函数、采用梯度下降法来计算目标函数的最小值。　　设第i层和第j层之间的权重为w(i,j)，对当前层权重反向传播修正权重的公式为：Δw(i,j) = α ····· 误差 · output(j) · (1 - output(j)) · output(i)　　通过反向传播修正链上的权重来改善输出情况。6.操作系统　　操作机：Linux_Ubuntu　　操作机默认用户：root7.实验工具    7.1.python　　Python是一种计算机程序设计语言。是一种动态的、面向对象的脚本语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。Python已经成为最受欢迎的程序设计语言之一。自从2004年以后，python的使用率呈线性增长。2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。　　由于Python语言的简洁性、易读性以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用Python语言讲授。　　众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。    7.2.NumPy　　NumPy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。　　NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用，以及核心的科学计算组织如：Lawrence Livermore，NASA用其处理一些本来使用C++，Fortran或Matlab等所做的任务。    7.3.SciPy       SciPy是一款方便、易于使用、专为科学和工程设计的Python工具包.它包括统计,优化,整合,线性代数模块,傅里叶变换,信号和图像处理,常微分方程求解器等等.8.导入numpy，scipy.special　　实验中将使用人工神经网络对含有110个手写识别数据的数据集进行识别。#导入库 import numpy #numpy是高级的数学计算库 import scipy.special #在这里用到scipy的expit（）函数作为sigmod（）函数 import matplotlib.pyplot9.学习人工神经网络类的框架人工神经网络类的整体框架如下：class neuralNetwork:     def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):         pass     def train(self, inputs_list, targets_list):         pass      def query(self, inputs_list):在_init_中。参数说明如下：self.inodes表示输入节点self.hnodes表示隐层节点self.onodes表示输出节点self.wih表示输入层到隐层的权重self.who表示隐层到输出层的权重self.lr表示学习率self.activation表示激活函数编写_init_函数，完整代码如下：class neuralNetwork:   def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):       self.inodes = inputnodes   #输入节点       self.hnodes = hiddennodes   #隐层节点       self.onodes = outputnodes   #输出节点       #权重链接       self.wih = numpy.random.normal(0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))       self.who = numpy.random.normal(0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))       # 学习率       self.lr = learningrate       # 激活函数直接调用self.activation_function       self.activation_function = lambda x: scipy.special.expit(x)       pass10.train函数实现整个神经网络的训练过程　　首先实现正向传播，隐层节点的输入值等于输入层的输入值乘以wih权重，代码如下：        hidden_inputs = numpy.dot(self.wih, inputs)         hidden_outputs = self.activation_function(hidden_inputs)　　输出层的输入值等于隐层输出值乘以who权重 。代码如下：        final_inputs = numpy.dot(self.who, hidden_outputs)         final_outputs = self.activation_function(final_inputs)　　正向传播结束后，使用反向传播算法调节链上权重。output_errors = targets - final_outputs         hidden_errors = numpy.dot(self.who.T, output_errors)          self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), numpy.transpose(hidden_outputs))         self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), numpy.transpose(inputs))　　train函数完整代码如下： def train(self, inputs_list, targets_list):         # 将输入和目标值转换为矩阵（numpy的数组）         inputs = numpy.array(inputs_list, ndmin=2).T         targets = numpy.array(targets_list, ndmin=2).T         hidden_inputs = numpy.dot(self.wih, inputs)         hidden_outputs = self.activation_function(hidden_inputs)         final_inputs = numpy.dot(self.who, hidden_outputs)         final_outputs = self.activation_function(final_inputs)         output_errors = targets - final_outputs         hidden_errors = numpy.dot(self.who.T, output_errors)          self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), numpy.transpose(hidden_outputs))         self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), numpy.transpose(inputs))         pass11.query函数　　实现输入测试数据，对得到的结果进行评估。将输入值经过正向传播算法得到结果即可　　代码如下： def query(self, inputs_list):         #将输入转换为矩阵         inputs = numpy.array(inputs_list, ndmin=2).T         hidden_inputs = numpy.dot(self.wih, inputs)         hidden_outputs = self.activation_function(hidden_inputs)         final_inputs = numpy.dot(self.who, hidden_outputs)         final_outputs = self.activation_function(final_inputs)         return final_outputs　　注意：将以上函数都写入在框架内。12.设定参数　　Mnist手写数据图片为28x28的分辨率，所以输入层采用784(28*28)个节点，隐层采用200(可自行调整)个节点，输出层采用10(0~9)个节点，学习率为0.1　　代码如下：# 输入层节点 隐层节点 输出层节点 input_nodes = 784 hidden_nodes = 200 output_nodes = 10 #学习率设定为0.1 learning_rate = 0.1 #创建出训练的神经网络 n = neuralNetwork(input_nodes,hidden_nodes,output_nodes, learning_rate)13.读取训练数据集　　代码如下：# 打开mnist_CSV训练文件 training_data_file = open("/mnt/dataset_54/mnist_train_100_bcdb280d7666ea5865e56b56d47167ec.csv", 'r') training_data_list = training_data_file.readlines() training_data_file.close()14.用训练数据集对神经网络进行训练　　代码如下：#训练网络 # epochs表示训练世代 epochs = 5 for e in range(epochs):     for record in training_data_list:         # 去掉，         all_values = record.split(',')         # inputs进行转换         inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01         # 把所有0转换为0.01         targets = numpy.zeros(output_nodes) + 0.01         # 把所有1转换为0.99         targets[int(all_values[0])] = 0.99         n.train(inputs, targets)         pass     pass15.读取测试数据集　　代码如下：# 打开mnist_CSV测试文件 test_data_file = open("/mnt/dataset_54/mnist_test_10_de377bdbad1fe5920e467c5dee8cb718.csv", 'r') test_data_list = test_data_file.readlines() test_data_file.close()16.将测试数据集读入训练好的神经网络中并输出结果　　代码如下：# 测试神经网络 # 用scorecaed统计正确的数目 scorecard = [] for record in test_data_list:     # 去除测试数据中的逗号     all_values = record.split(',')     # 正确的答案放在第零位标签     correct_label = int(all_values[0])     print(correct_label,"correct answer")     # 处理测试数据     inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01     outputs = n.query(inputs)     #获得输出的概率的最大值所对应的标签     label = numpy.argmax(outputs)          print(outputs)     print(label,"network's answer")     print("\n")     #计量正确识别数     if (label == correct_label):         #正确的就在scorecard加个1         scorecard.append(1)     else:         # 错误的就在scorecard加个0         scorecard.append(0)         pass     pass　　这是其中三组输出结果，correct answer是图片的标签即正确答案，network's answer是神经网络识别的结果即测试结果。中间的矩阵是神经网络的十个输出节点输出的值，自上而下分别代表着0~9的概率，概率高者即为神经网络得到的答案。完整代码如下：#导入库 import numpy #numpy是高级的数学计算库 import scipy.special #在这里用到scipy的expit（）函数作为sigmod（）函数 import matplotlib.pyplot class neuralNetwork:     def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):         self.inodes = inputnodes   #输入节点         self.hnodes = hiddennodes   #隐层节点         self.onodes = outputnodes   #输出节点         #权重链接         self.wih = numpy.random.normal(0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))         self.who = numpy.random.normal(0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))          # 学习率         self.lr = learningrate         # 激活函数直接调用self.activation_function         self.activation_function = lambda x: scipy.special.expit(x)         pass                  def train(self, inputs_list, targets_list):         # 将输入和目标值转换为矩阵（numpy的数组）         inputs = numpy.array(inputs_list, ndmin=2).T         targets = numpy.array(targets_list, ndmin=2).T         hidden_inputs = numpy.dot(self.wih, inputs)         hidden_outputs = self.activation_function(hidden_inputs)         final_inputs = numpy.dot(self.who, hidden_outputs)         final_outputs = self.activation_function(final_inputs)         output_errors = targets - final_outputs         hidden_errors = numpy.dot(self.who.T, output_errors)          self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), numpy.transpose(hidden_outputs))         self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), numpy.transpose(inputs))         pass              def query(self, inputs_list):         #将输入转换为矩阵         inputs = numpy.array(inputs_list, ndmin=2).T         hidden_inputs = numpy.dot(self.wih, inputs)         hidden_outputs = self.activation_function(hidden_inputs)         final_inputs = numpy.dot(self.who, hidden_outputs)         final_outputs = self.activation_function(final_inputs)         return final_outputs # 输入层节点 隐层节点 输出层节点 input_nodes = 784 hidden_nodes = 200 output_nodes = 10 #学习率设定为0.1 learning_rate = 0.1 #创建出训练的神经网络 n = neuralNetwork(input_nodes,hidden_nodes,output_nodes, learning_rate) # 打开mnist_CSV训练文件 training_data_file = open("/mnt/dataset_54/mnist_train_100_bcdb280d7666ea5865e56b56d47167ec.csv", 'r') training_data_list = training_data_file.readlines() training_data_file.close() #训练网络 # epochs表示训练世代 epochs = 5 for e in range(epochs):     for record in training_data_list:         # 去掉，         all_values = record.split(',')         # inputs进行转换         inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01         # 把所有0转换为0.01         targets = numpy.zeros(output_nodes) + 0.01         # 把所有1转换为0.99         targets[int(all_values[0])] = 0.99         n.train(inputs, targets)         pass     pass # 打开mnist_CSV测试文件 test_data_file = open("/mnt/dataset_54/mnist_test_10_de377bdbad1fe5920e467c5dee8cb718.csv", 'r') test_data_list = test_data_file.readlines() test_data_file.close() # 测试神经网络 # 用scorecaed统计正确的数目 scorecard = [] for record in test_data_list:     # 去除测试数据中的逗号     all_values = record.split(',')     # 正确的答案放在第零位标签     correct_label = int(all_values[0])     print(correct_label,"correct answer")     # 处理测试数据     inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01     outputs = n.query(inputs)     #获得输出的概率的最大值所对应的标签     label = numpy.argmax(outputs)     print(outputs)     print(label,"network's answer")     #计量正确识别数     if (label == correct_label):         #正确的就在scorecard加个1         scorecard.append(1)     else:         # 错误的就在scorecard加个0         scorecard.append(0)         pass     pass # 计算正确率 scorecard_array = numpy.asarray(scorecard) print ("performance = ", scorecard_array.sum() / scorecard_array.size)

【Python算法】分类与预测——logistic回归分析1.logistic回归定义      logistic回归是一种广义线性回归（generalized linear model），因此与多重线性回归分析有很多相同之处。它们的模型形式基本上相同，都具有 w‘x+b，其中w和b是待求参数，其区别在于他们的因变量不同，多重线性回归直接将w‘x+b作为因变量，即y =w‘x+b，而logistic回归则通过函数L将w‘x+b对应一个隐状态p，p =L(w‘x+b),然后根据p 与1-p的大小决定因变量的值。如果L是logistic函数，就是logistic回归，如果L是多项式函数就是多项式回归。        logistic回归的因变量可以是二分类的，也可以是多分类的，但是二分类的更为常用，也更加容易解释，多类可以使用softmax方法进行处理。实际中最为常用的就是二分类的logistic回归。2.操作系统　　操作机：Linux_Ubuntu　　操作机默认用户：root3.实验工具       Python是一种计算机程序设计语言。是一种动态的、面向对象的脚本语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。Python已经成为最受欢迎的程序设计语言之一。自从2004年以后，python的使用率呈线性增长。2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。　　由于Python语言的简洁性、易读性以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用Python语言讲授。       众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。4.Numpy      NumPy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。　　NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用，以及核心的科学计算组织如：Lawrence Livermore，NASA用其处理一些本来使用C++，Fortran或Matlab等所做的任务。5.scikit-learn      scikit-learn，Python 中的机器学习，简单高效的数据挖掘和数据分析工具，可供大家使用，可在各种环境中重复使用，建立在 NumPy，SciPy 和 matplotlib 上开放源码，可商业使用 - BSD license。6.Matplotlib       Matplotlib 是一个 Python 的 2D绘**，它以各种硬拷贝格式和跨平台的交互式环境生成出版质量级别的图形。通过 Matplotlib，开发者可以仅需要几行代码，便可以生成绘图，直方图，功率谱，条形图，错误图，散点图等。7.pandas        Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。8.导入所需要的库:numpy,matplotlib.pyplot,pandas代码如下:# Importing the libraries import numpy as np import matplotlib.pyplot as plt import pandas as pd9.加载数据集代码如下：# Importing the dataset dataset = pd.read_csv('/mnt/dataset_29/Social_Network_Ads_82e4aa0627105a2d22b70d7ad0bfeda0.csv')   注意：数据集以实际位置为准 X = dataset.iloc[:, [2, 3]].values y = dataset.iloc[:, 4].values注意：实验中以数据集的具体为准。如下给出数据，可将数据创建响相应的数据集用于字日常训练，也可在实验平台中数据集模块下的的“社交网络数据集”中进行查看。数据集如下：（见附件）10.将数据集分割为训练集和测试集代码如下：# Splitting the dataset into the Training set and Test set from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)11.特征缩放代码如下：# Feature Scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test)12.使用逻辑回归对数据进行处理代码如下：from sklearn.linear_model import LogisticRegression classifier = LogisticRegression() classifier.fit(X_train, y_train)13.对测试集进行分类代码如下：# Predicting the Test set results y_pred = classifier.predict(X_test)14.制造混淆矩阵评估分类器性能代码如下：from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred)15.绘制训练集和测试集绘制训练集数据结果：from matplotlib.colors import ListedColormap X_set,y_set=X_train,y_train X1,X2=np. meshgrid(np. arange(start=X_set[:,0].min()-1, stop=X_set[:, 0].max()+1, step=0.01),                    np. arange(start=X_set[:,1].min()-1, stop=X_set[:,1].max()+1, step=0.01)) plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(),X2.ravel()]).T).reshape(X1.shape),              alpha = 0.75, cmap = ListedColormap(('red', 'green'))) plt.xlim(X1.min(),X1.max()) plt.ylim(X2.min(),X2.max()) for i,j in enumerate(np. unique(y_set)):     plt.scatter(X_set[y_set==j,0],X_set[y_set==j,1],                 c = ListedColormap(('red', 'green'))(i), label=j) plt. title(' LOGISTIC(Training set)') plt. xlabel(' Age') plt. ylabel(' Estimated Salary') plt. legend() plt. show()给测试集数据分类：X_set,y_set=X_test,y_test X1,X2=np. meshgrid(np. arange(start=X_set[:,0].min()-1, stop=X_set[:, 0].max()+1, step=0.01),                    np. arange(start=X_set[:,1].min()-1, stop=X_set[:,1].max()+1, step=0.01)) plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(),X2.ravel()]).T).reshape(X1.shape),              alpha = 0.75, cmap = ListedColormap(('red', 'green'))) plt.xlim(X1.min(),X1.max()) plt.ylim(X2.min(),X2.max()) for i,j in enumerate(np. unique(y_set)):     plt.scatter(X_set[y_set==j,0],X_set[y_set==j,1],                 c = ListedColormap(('red', 'green'))(i), label=j) plt. title(' LOGISTIC(Test set)') plt. xlabel(' Age') plt. ylabel(' Estimated Salary') plt. legend() plt. show()

h5py 安装失败，首先报libhdf5.so 不存在，然后尝试下载相关rpm包安装，会二次依赖libgfortran.so，而gcc-gfortran.aarch64 已在系统中通过yum成功安装。gfortran的这两个版本之间不匹配的情况下，请问有什么好的办法来解决？# 系统信息 欧拉 2.8 [root@bms-aiserver-ak201 h5py]# cat /etc/os-release NAME="EulerOS" VERSION="2.0 (SP8)" ID="euleros" ID_LIKE="rhel fedora centos" VERSION_ID="2.0" PRETTY_NAME="EulerOS 2.0 (SP8)" ANSI_COLOR="0;31" # 尝试手动rpm 安装，失败， 报包缺失。 [root@bms-aiserver-ak201 h5py]# rpm -i hdf5-devel-1.8.15-7.3.1.aarch64.rpm warning: hdf5-devel-1.8.15-7.3.1.aarch64.rpm: Header V3 RSA/SHA256 Signature, key ID 3dbdc284: NOKEY error: Failed dependencies:         hdf5 = 1.8.15 is needed by hdf5-devel-1.8.15-7.3.1.aarch64         hdf5-devel-data = 1.8.15 is needed by hdf5-devel-1.8.15-7.3.1.aarch64         libhdf5-10 = 1.8.15 is needed by hdf5-devel-1.8.15-7.3.1.aarch64         libhdf5_hl10 = 1.8.15 is needed by hdf5-devel-1.8.15-7.3.1.aarch64 # 手动将包下过来，安装继续报二次依赖不满足，实际上二次依赖在系统中可以通过yum install  libgfortran 安装，但是却是版本不兼容        [root@bms-aiserver-ak201 h5py]# ll total 10444 -rw------- 1 root root  297763 Mar  3 14:40 hdf5-1.8.15-7.3.1.aarch64.rpm -rw------- 1 root root 9964562 Mar  3 14:40 hdf5-1.8.15-7.3.1.src.rpm -rw------- 1 root root  333083 Mar  3 14:40 hdf5-devel-1.8.15-7.3.1.aarch64.rpm -rw------- 1 root root   19530 Mar  3 14:40 hdf5-devel-data-1.8.15-7.3.1.aarch64.rpm -rw------- 1 root root   73719 Mar  3 14:40 libhdf5_hl10-1.8.15-7.3.1.aarch64.rpm [root@bms-aiserver-ak201 h5py]# rpm -i libhdf5_hl10-1.8.15-7.3.1.aarch64.rpm warning: libhdf5_hl10-1.8.15-7.3.1.aarch64.rpm: Header V3 RSA/SHA256 Signature, key ID 3dbdc284: NOKEY error: Failed dependencies:         libgfortran.so.3()(64bit) is needed by libhdf5_hl10-1.8.15-7.3.1.aarch64         libgfortran.so.3(GFORTRAN_1.0)(64bit) is needed by libhdf5_hl10-1.8.15-7.3.1.aarch64         libhdf5.so.10()(64bit) is needed by libhdf5_hl10-1.8.15-7.3.1.aarch64         libhdf5_fortran.so.10()(64bit) is needed by libhdf5_hl10-1.8.15-7.3.1.aarch64 [root@bms-aiserver-ak201 h5py]# sudo yum list |grep fortran gcc-gfortran.aarch64                                                 7.3.0-20190804.h22.eulerosv2r8                                @base libgfortran.aarch64                                                  7.3.0-20190804.h22.eulerosv2r8                                @base ... [root@bms-aiserver-ak201 h5py]# locate fortran.so /usr/lib/gcc/aarch64-linux-gnu/7.3.0/libgfortran.so /usr/lib64/libgfortran.so.4 /usr/lib64/libgfortran.so.4.0.0 /usr/lib64/python2.7/site-packages/scipy/io/_test_fortran.so # 发现系统有 libgfortran.so.4， 而前面依赖是 libgfortran.so.3()， 故再次尝试手动安装so.3 # 然而安装的时候，发现与本地系统冲突了 [root@bms-aiserver-ak201 tools]# rpm -i libgfortran-4.8.5-39.el7.aarch64.rpm warning: libgfortran-4.8.5-39.el7.aarch64.rpm: Header V3 RSA/SHA256 Signature, key ID 305d49d6: NOKEY         package libgfortran-7.3.0-20190804.h22.eulerosv2r8.aarch64 (which is newer than libgfortran-4.8.5-39.el7.aarch64) is already installed

【Python算法】分类与预测——Python随机森林1.随机森林定义　　随机森林是一种多功能的机器学习算法，能够执行回归和分类的任务。同时，它也是一种数据降维手段，在处理缺失值、异常值以及其他数据探索等方面，取得了不错的成效。另外，它还担任了集成学习中的重要方法，在将几个低效模型整合为一个高效模型时大显身手。在随机森林中，会生成很多的决策树，当在基于某些属性对一个新的对象进行分类判别时，随机森林中的每一棵树都会给出自己的分类选择，并由此进行“投票”，森林整体的输出结果将会是票数最多的分类选项；而在回归问题中，随机森林的输出将会是所有决策树输出的平均值。2.随机森林的优缺点　　该算法的优点主要有以下几个方面：　　随机森林算法能解决分类与回归两种类型的问题，并在这两个方面都有相当好的估计表现；　　随机森林对于高维数据集的处理能力令人兴奋，它可以处理成千上万的输入变量，并确定最重要的变量，因此被认为是一个不错的降维方法。此外，该模型能够输出变量的重要性程度，这是一个非常便利的功能；　　在对缺失数据进行估计时，随机森林是一个十分有效的方法。就算存在大量的数据缺失，随机森林也能较好地保持精确性；　　当存在分类不平衡的情况时，随机森林能够提供平衡数据集误差的有效方法；      模型的上述性能可以被扩展运用到未标记的数据集中，用于引导无监督聚类、数据透视和异常检测；　　随机森林算法中包含了对输入数据的重复自抽样过程，即所谓的bootstrap抽样。　　这样一来，数据集中大约三分之一将没有用于模型的训练而是用于测试，这样的数据被称为out of bag samples，通过这些样本估计的误差被称为out of bag error。研究表明，这种out of bag方法的与测试集规模同训练集一致的估计方法有着相同的精确程度，因此在随机森林中我们无需再对测试集进行另外的设置。该算法的缺点主要有以下几个方面：　　(1)随机森林在解决回归问题时并没有像它在分类中表现的那么好，这是因为它并不能给出一个连续型的输出。　　(2)当进行回归时，随机森林不能够作出超越训练集数据范围的预测，这可能导致在对某些还有特定噪声的数据进行建模时出现过度拟合。　　(3)对于许多统计建模者来说，随机森林给人的感觉像是一个黑盒子—几乎无法控制模型内部的运行，只能在不同的参数和随机种子之间进行尝试。3.随机森林执行步骤　　在随机森林中，每一个决策树“种植”和“生长”的规则如下所示：　　(1) 假设训练集中的样本个数为N，然后通过有重置的重复多次抽样来获得这N个样 本，这样的抽样结果将作为生成决策树的训练集；　　(2) 如果有M个输入变量，每个节点都将随机选择m(m<M)个特定的变量，然后运用这m个变量来确定最佳的分裂点。在决策树的生成过程中，m的值是保持不变的；　　(3) 每棵决策树都最大可能地进行生长而不进行剪枝；　　(4) 通过对所有的决策树进行加总来预测新的数据（在分类时采用多数投票，在回归时 采用平均）。4.操作系统　　操作机：Linux_Ubuntu　　操作机默认用户：root5.实验工具       Python是一种计算机程序设计语言。是一种动态的、面向对象的脚本语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。Python已经成为最受欢迎的程序设计语言之一。自从2004年以后，python的使用率呈线性增长。2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。　　由于Python语言的简洁性、易读性以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用Python语言讲授。       众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。6.Numpy      NumPy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。　　NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用，以及核心的科学计算组织如：Lawrence Livermore，NASA用其处理一些本来使用C++，Fortran或Matlab等所做的任务。7.scikit-learn      scikit-learn，Python 中的机器学习，简单高效的数据挖掘和数据分析工具，可供大家使用，可在各种环境中重复使用，建立在 NumPy，SciPy 和 matplotlib 上开放源码，可商业使用 - BSD license。8.Matplotlib       Matplotlib 是一个 Python 的 2D绘**，它以各种硬拷贝格式和跨平台的交互式环境生成出版质量级别的图形。通过 Matplotlib，开发者可以仅需要几行代码，便可以生成绘图，直方图，功率谱，条形图，错误图，散点图等。9.pandas        Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。10.导入所需要的库:numpy,matplotlib.pyplot,pandas代码如下:# Importing the libraries import numpy as np import matplotlib.pyplot as plt import pandas as pd11.加载数据集代码如下：# Importing the dataset dataset = pd.read_csv('/mnt/dataset_29/Social_Network_Ads_82e4aa0627105a2d22b70d7ad0bfeda0.csv')   注意：数据集以实际位置为准 X = dataset.iloc[:, [2, 3]].values y = dataset.iloc[:, 4].values注意：实验中以数据集的具体为准。如下给出数据，可将数据创建响相应的数据集用于字日常训练，也可在实验平台中数据集模块下的的“社交网络数据集”中进行查看。数据集如下：（见附件）12.将数据集分割为训练集和测试集代码如下：# Splitting the dataset into the Training set and Test set from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)13.特征缩放代码如下：# Feature Scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test)14.调试训练集的随机森林代码如下：from sklearn.ensemble import RandomForestClassifier classifier = RandomForestClassifier(n_estimators = 10, criterion = 'entropy', random_state = 0) classifier.fit(X_train, y_train)15.对测试集进行分类代码如下：# Predicting the Test set results y_pred = classifier.predict(X_test)16.制作混淆矩阵来评估模型性能代码如下：# Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred)17.绘制训练数据分类结果代码如下：# Visualising the Training set results from matplotlib.colors import ListedColormap X_set, y_set = X_train, y_train X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),                      np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01)) plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),              alpha = 0.75, cmap = ListedColormap(('red', 'green'))) plt.xlim(X1.min(), X1.max()) plt.ylim(X2.min(), X2.max()) for i, j in enumerate(np.unique(y_set)):     plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],                 c = ListedColormap(('orange', 'blue'))(i), label = j) plt.title('Classifier (Training set)') plt.xlabel('Age') plt.ylabel('Estimated Salary') plt.legend() plt.show()训练数据分类结果如下：18.绘制测试数据分类结果代码如下：# Visualising the Test set results from matplotlib.colors import ListedColormap X_set, y_set = X_test, y_test X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),                      np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01)) plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),              alpha = 0.75, cmap = ListedColormap(('red', 'green'))) plt.xlim(X1.min(), X1.max()) plt.ylim(X2.min(), X2.max()) for i, j in enumerate(np.unique(y_set)):     plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],                 c = ListedColormap(('orange', 'blue'))(i), label = j) plt.title('Classifier (Test set)') plt.xlabel('Age') plt.ylabel('Estimated Salary') plt.legend() plt.show()