程序博客网 > linux内核调试工具

“集体智慧编程”之第三章：“发现群组”的 分级聚类

来源：互联网 发布：linux内核调试工具 编辑：程序博客网 时间：2024/06/06 00:31

聚类

这章的主旨是数据聚类：聚集关系紧密的人或者事物。
聚类有什么好处呢？从推荐的角度来看，也是一种求相似用户的方式。此外，如果我们统计消费者此前购买的物品，再做一个聚类，就能分析出什么样的消费者会想要得到什么。如此抽象的描述非常不利于学习，不过下面本章第二个例子就能很好解释上面这句抽象的话。拭目以待吧。

聚类属于无监督学习（unsupervised learning），这不知道为什么这个词会被翻译成无监督，在我了解了这个含义之后，我倒认为无监督的学习和监督学习的最大区别就是是否产生了直接的结果。书中所言：无监督学习算法不是利用带有某种正确的答案样本数据进行‘训练’，它们的目的是要在一组数据中寻找某种结构，而这些结构本身不会告诉我们正在寻找的答案。而监督学习，我认为是利用样本的输入和样本自带的输出来训练模型，训练好之后，我们再传入一个类似输入的时候，那么模型就会为我们产生结果。这个结果和之前的训练有很大的关系。

无监督学习的算法有：

  • 非负矩阵因式分解
  • 自组织映射

监督学习法

  • 神经网络
  • 决策树
  • 向量支持机
  • 贝叶斯过滤

对博客聚类的例子

通过例子进行学习是我认为最好的方式，空洞的理论只会让人不明觉厉。
下面这个例子是要给一群博客聚类。依据也非常简单，我们根据不同的词在博客中出现的次数。词是我们规定的，我们认为这些词的在博客中出现的不同数量能够帮助我们鉴别博客的类型。本书也指出了如何构造这个数据集。最后构造出来的就是一个blogdata.txt的文档，下图是其的一个子集，第一列就是博客的名字。

分级聚类的原理

聚类的方式是多种多样的，我们第一种方式是分级聚类。


分级聚类是通过连续不断地将最为相似的群组两两合并，直到合并为一个为止。当然，最开始合并的时候只是两篇博客。下图展示了如何将5个元素合并的过程，A和B最开始最相似，所以合并成了一个。

 

在聚类完成后，我们会使用一种图形化的方式来展现所得到的结果。这次我们使用一种树状图的方式来表达最终聚类的情况。如下图所示：

 

 

上图不仅能看出哪些元素属于一个类，还可以看出不同元素间相似的程度。比如A与B，它们合并成一个元素的距离远小于D和E合并成一个元素的距离。所以，A与B的紧密程度要大于D和E。
讲完原理就让我们开始吧。

 

读数据带内存


首先我们要讲blogdata.txt读入内存，代码如下：

[python] view plain copy
  1. def readfile(filename):  
  2.     lines=[line for line in file(filename)]  
  3.   
  4.     #第一行是列标题，也就是被统计的单词是哪些  
  5.     colnames=lines[0].strip().split('\t')[1:]#之所以从1开始，是因为第0列是用来放置博客名了  
  6.     rownames=[]  
  7.     data=[]  
  8.     for line in lines[1:]:#第一列是单词，但二列开始才是对不同的单词的计数  
  9.         p=line.strip().split('\t')  
  10.         #每行都是的第一列都是行名  
  11.         rownames.append(p[0])  
  12.         #剩余部分就是该行对应的数据  
  13.         data.append([float(x) for x in p[1:]])#data是一个列表，这个列表里每一个元素都是一个列表，每一列表的元素就是对应了colnames[]里面的单词  
  14.     return rownames,colnames,data  
  15.   
  16.    

 

计算相似度


下面我们就要计算两篇博客的相似度，在本个例子中我们使用pearson算法，这是因为每一篇博客的单词的总词数是不一样的，这就相当于在用户评价电影的体系中，某位用户打的分总是是偏高的情况，总词数偏多，那么相应地，我们想要统计的词数也会偏多，但是pearson算法完成可以修复者问题，这是因为pearson算法判断是两组数据和某一条直线的拟合程度。所以不会受到总的单词数偏多的情况下的干扰。
下面是计算代码：

[python] view plain copy
  1. def pearson(v1,v2):  
  2.     #先求和  
  3.     sum1=sum(v1)  
  4.     sum2=sum(v2)  
  5.   
  6.     #求平方和  
  7.     sum1Sq=sum([pow(v,2) for v in v1])  
  8.     sum2Sq=sum([pow(v,2) for v in v2])  
  9.   
  10.     #求乘积之和  
  11.     pSum=sum([v1[i]*v2[i] for i in range(len(v1))])  
  12.   
  13.     #计算pearson相关系数  
  14.     num=pSum-(sum1*sum2/len(v1))  
  15.     den=sqrt((sum1Sq-pow(sum1,2)/len(v1))*(sum2Sq-pow(sum2,2)/len(v1)))  
  16.     if den==0:return 0  
  17.   
  18.     return 1.0-num/den#因为在本题中，我们想要相似度也大的两个元素的距离越近，所以才用1去减它们  


聚类计算


为了画出图像，使用面向对象的思维来编程是非常方便的，我们将图中每一个节点都看成是一个对象。首先我们来定义一个类。
代码如下：
#图中每一个点都是一个该类的对象，而其中叶节点显然就是原始数据，而枝节点的数据主要来自其叶节点的均值。

[python] view plain copy
  1. class bicluster:  
  2.     def __init__(self,vec,left=None,right=None,distance=0.0,id=None):  
  3.         self.left=left  
  4.         self.right=right  
  5.         self.vec=vec#就是词频列表  
  6.         self.id=id  
  7.         self.distance=distance  
  8.   
  9.    


接着，我们开始聚类计算，这也是一个比较耗时的过程，因为会对每一博客的相似度进行计算。实际上远不至每一对，还有新合并的节点。该函数会接受一个计算相似度的函数和一个列表数组，列表数组就是的就是所以博客的词频，词频又列表数组的形成存在，说直接一点就是上面生成的那个data列表数组。最后返回一个bicluster的对象，只有一个，但是这个对象是根节点，如果扩展其左右孩子，最后会得一个类似于上面的那副树状图。实际上最后我们就是要画出那个树状图。
代码如下：

[python] view plain copy
  1. def hcluster(rows,distance=pearson):  
  2.     distances={}#每计算一对节点的距离值就会保存在这个里面，这样避免了重复计算  
  3.     currentclustid=-1  
  4.   
  5.     #最开始的聚类就是数据集中的一行一行，每一行都是一个元素  
  6.     #clust是一个列表，列表里面是一个又一个biccluster的对象  
  7.     clust=[bicluster(rows[i],id=i) for i in range(len(rows))]  
  8.   
  9.     while len(clust)>1:  
  10.         lowestpair=(0,1)#先假如说lowestpair是0和1号  
  11.         closest=distance(clust[0].vec,clust[1].vec)#同样将0和1的pearson相关度计算出来放着。  
  12.         #遍历每一对节点，找到pearson相关系数最小的  
  13.         for i in range(len(clust)):  
  14.             for j in range(i+1,len(clust)):  
  15.                 #用distances来缓存距离的计算值  
  16.                 if(clust[i].id,clust[j].id) not in distances:  
  17.                     distances[(clust[i].id,clust[j].id)]=distance(clust[i].vec,clust[j].vec)  
  18.                 d=distances[(clust[i].id,clust[j].id)]  
  19.                 if d<closest:  
  20.                     closest=d  
  21.                     lowestpair=(i,j)  
  22.         #找到这个次循环的最小一对后，产生新的枝节点。先计算出这个新的枝节点的词频  
  23.         mergevec=[(clust[lowestpair[0]].vec[i]+clust[lowestpair[1]].vec[i])/2.0 for i in range(len(clust[0].vec))]  
  24.   
  25.         #建立新的聚类  
  26.         newcluster=bicluster(mergevec,left=clust[lowestpair[0]],right=clust[lowestpair[1]],distance=closest,id=currentclustid)  
  27.   
  28.         #不在初始集合中的聚类，其id设置为负数  
  29.         currentclustid-=1  
  30.         del clust[lowestpair[1]]  
  31.         del clust[lowestpair[0]]  
  32.         clust.append(newcluster)  
  33.   
  34.     #当只有一个元素之后，就返回，这个节点相当于根节点  
  35.     return clust[0]  

 

粗略的结果图

 

我们确实要画树状图，但是现在先写一份代码在控制台画出树状图。原来非常简单，反正每行打印一个，要么是分支，要么就是叶节点，然后就控制后缩进，越到后面缩进越大。
代码如下：

[python] view plain copy
  1. #我们急于验证上面的函数，所以先写一个简单的函数来打印节点，形式是和文件系统层级结构相关。  
  2. def printclust(clust,labels=None,n=0):  
  3.     #利用缩进来建立层级布局  
  4.     for i in range(n):print ' ',  
  5.     if clust.id<0:  
  6.         #负数代表这是一个分支  
  7.         print '-'  
  8.     else:  
  9.         #正数代表这是一个叶节点  
  10.         if labels==None: print clust.id  
  11.         else:print labels[clust.id]  
  12.     if clust.left!=None:printclust(clust.left,labels=labels,n=n+1)  
  13.     if clust.right!=None:printclust(clust.right,labels=labels,n=n+1)      


执行代码：

[python] view plain copy
  1. blognames,words,data=readfile('blogdata.txt')  
  2. clust=hcluster(data)  
  3. printclust(clust,labels=blognames)  



执行结果：

[python] view plain copy
  1. >>>   
  2. -  
  3.   gapingvoid: "cartoons drawn on the back of business cards"  
  4.   -  
  5.     -  
  6.       Schneier on Security  
  7.       Instapundit.com  
  8.     -  
  9.       The Blotter  
  10.       -  
  11.         -  
  12.           MetaFilter  
  13.           -  
  14.             SpikedHumor  
  15.             -  
  16.               Captain's Quarters  
  17.               -  
  18.                 Michelle Malkin  
  19.                 -  
  20.                   -  
  21.                     NewsBusters.org - Exposing Liberal Media Bias  
  22.                     -  
  23.                       -  
  24.                         Hot Air  
  25.                         Crooks and Liars  
  26.                       -  
  27.                         Power Line  
  28.                         Think Progress  
  29.                   -  
  30.                     Andrew Sullivan | The Daily Dish  
  31.                     -  
  32.                       Little Green Footballs  
  33.                       -  
  34.                         Eschaton  
  35.                         -  
  36.                           Talking Points Memo: by Joshua Micah Marshall  
  37.                           Daily Kos  
  38.         -  
  39.           43 Folders  
  40.           -  
  41.             TechEBlog  
  42.             -  
  43.               -  
  44.                 Mashable!  
  45.                 Signum sine tinnitu--by Guy Kawasaki  
  46.               -  
  47.                 -  
  48.                   -  
  49.                     Slashdot  
  50.                     -  
  51.                       MAKE Magazine  
  52.                       Boing Boing  
  53.                   -  
  54.                     -  
  55.                       Oilman  
  56.                       -  
  57.                         Online Marketing Report  
  58.                         -  
  59.                           Treehugger  
  60.                           -  
  61.                             SimpleBits  
  62.                             -  
  63.                               Cool Hunting  
  64.                               -  
  65.                                 Steve Pavlina's Personal Development Blog  
  66.                                 -  
  67.                                   -  
  68.                                     ScienceBlogs : Combined Feed  
  69.                                     Pharyngula  
  70.                                   -  
  71.                                     BuzzMachine  
  72.                                     -  
  73.                                       Copyblogger  
  74.                                       -  
  75.                                         -  
  76.                                           The Viral Garden  
  77.                                           Seth's Blog  
  78.                                         -  
  79.                                           -  
  80.                                             Bloggers Blog: Blogging the Blogsphere  
  81.                                             -  
  82.                                               Sifry's Alerts  
  83.                                               ProBlogger Blog Tips  
  84.                                           -  
  85.                                             -  
  86.                                               Valleywag  
  87.                                               Scobleizer - Tech Geek Blogger  
  88.                                             -  
  89.                                               -  
  90.                                                 O'Reilly Radar  
  91.                                                 456 Berea Street  
  92.                                               -  
  93.                                                 Lifehacker  
  94.                                                 -  
  95.                                                   Quick Online Tips  
  96.                                                   -  
  97.                                                     Publishing 2.0  
  98.                                                     -  
  99.                                                       Micro Persuasion  
  100.                                                       -  
  101.                                                         A Consuming Experience (full feed)  
  102.                                                         -  
  103.                                                           John Battelle's Searchblog  
  104.                                                           -  
  105.                                                             Search Engine Watch Blog  
  106.                                                             -  
  107.                                                               Read/WriteWeb  
  108.                                                               -  
  109.                                                                 Official Google Blog  
  110.                                                                 -  
  111.                                                                   Search Engine Roundtable  
  112.                                                                   -  
  113.                                                                     Google Operating System  
  114.                                                                     Google Blogoscoped  
  115.                     -  
  116.                       -  
  117.                         -  
  118.                           -  
  119.                             Blog Maverick  
  120.                             -  
  121.                               Download Squad  
  122.                               -  
  123.                                 CoolerHeads Prevail  
  124.                                 -  
  125.                                   Joystiq  
  126.                                   The Unofficial Apple Weblog (TUAW)  
  127.                           -  
  128.                             Autoblog  
  129.                             -  
  130.                               Engadget  
  131.                               TMZ.com  
  132.                         -  
  133.                           Matt Cutts: Gadgets, Google, and SEO  
  134.                           -  
  135.                             PaulStamatiou.com  
  136.                             -  
  137.                               -  
  138.                                 GigaOM  
  139.                                 TechCrunch  
  140.                               -  
  141.                                 -  
  142.                                   Techdirt  
  143.                                   Creating Passionate Users  
  144.                                 -  
  145.                                   Joho the Blog  
  146.                                   -  
  147.                                     -  
  148.                                       PerezHilton.com  
  149.                                       Jeremy Zawodny's blog  
  150.                                     -  
  151.                                       Joi Ito's Web  
  152.                                       -  
  153.                                         ongoing  
  154.                                         -  
  155.                                           Joel on Software  
  156.                                           -  
  157.                                             -  
  158.                                               we make money not art  
  159.                                               -  
  160.                                                 plasticbag.org  
  161.                                                 -  
  162.                                                   Signal vs. Noise  
  163.                                                   -  
  164.                                                     kottke.org  
  165.                                                     -  
  166.                                                       Neil Gaiman's Journal  
  167.                                                       -  
  168.                                                         -  
  169.                                                           The Huffington Post | Raw Feed  
  170.                                                           -  
  171.                                                             Wonkette  
  172.                                                             -  
  173.                                                               Gawker  
  174.                                                               -  
  175.                                                                 The Superficial - Because You're Ugly  
  176.                                                                 Go Fug Yourself  
  177.                                                         -  
  178.                                                           Deadspin  
  179.                                                           Gothamist  
  180.                                             -  
  181.                                               Kotaku  
  182.                                               Gizmodo  
  183.                       -  
  184.                         Shoemoney - Skills to pay the bills  
  185.                         -  
  186.                           flagrantdisregard  
  187.                           -  
  188.                             WWdN: In Exile  
  189.                             -  
  190.                               Derek Powazek  
  191.                               -  
  192.                                 lifehack.org  
  193.                                 Dave Shea's mezzoblue  
  194.                 -  
  195.                   Wired News: Top Stories  
  196.                   -  
  197.                     Topix.net Weblog  
  198.                     Bloglines | News  
  199. >>>   
  200.   
  201.    

 

画出树状图


实际上，到底，我们分级聚类已经学完了。但是为了使我们的结果更加易于观察，我们需要画出树状图。
准备工作：请将Python画图的库文件PIL，windows下非常简单，直接下载对应版本，然后去安装即可。
第一步：就是计算出高度。书中提出的办法是，写一个函数计算有多少叶节点，一个叶节点的高度算1，如果不是叶节点肯定就是枝节点，而枝节点的高度就是叶节点之和。但是我观察了一下图，我觉得高度不就是整个叶节点之和么？每一个叶节点就是就是一个博客名字，那高度不就博客的个数么？为什么还写个函数去算呢？
代码如下：

[python] view plain copy
  1. def getheight(clust):  
  2.     #这是一个叶节点吗？若是，则高度为1  
  3.     if clust.left==None and clust.right ==None:return 1  
  4.     #否则，高度为每个分支的高度之和  
  5.     return getheight(clust.left)+getheight(clust.right)  

 

知道高度之后就是知道宽度，之前我们提到过，每一个叶节点与枝节点的距离越远，表示两者两个元素的相似度越低。由此可见，在聚类过程中，叶节点到枝节点的距离是各不相同的，看起来肯定是没有那么工整。
代码如下：

[python] view plain copy
  1. def getdepth(clust):  
  2.     #一个叶节点的距离是0.0，这是因为叶节点之后就没有了，将其放在最左边也没事  
  3.     if clust.left==None and clust.right ==None:return 0  
  4.   
  5.     #而一个枝节点的距离等于左右两侧分支中距离较大的那一个  
  6.     #加上自身距离：所谓自身距离，与就是某节点与两一节点合并时候的相似度  
  7.     return max(getdepth(clust.left),getdepth(clust.right))+clust.distance  


下面是画出那张大的背景图，在此，我们为每一个叶节点分配20个像素，但是整张图片的宽度，我们固定为了1200。
代码如下：

[python] view plain copy
  1. def drawdendrogram(clust,labels,jpeg='clusters.jpg'):  
  2.     #高度和宽度  
  3.     h=getheight(clust)*20  
  4.     w=1200  
  5.     depth=getdepth(clust)  
  6.   
  7.     #我们固定了宽度，所以需要对每一个节点的横向摆放做一个缩放，而不像高度一样，每一个叶节点都分配20  
  8.     scaling=float(w-150)/depth  
  9.   
  10.     #新建一张白色的背景图片  
  11.     img=Image.new('RGB',(w,h),(255,255,255))  
  12.     draw=ImageDraw.Draw(img)  
  13.   
  14.     draw.line((0,h/2,10,h/2),fill=(255,0,0))#仅仅是画了一个起点  
  15.       
  16.     #画第一个节点  
  17.     drawnode(draw,clust,10,(h/2),scaling,labels)  
  18.     img.save(jpeg,'JPEG')  
  19.   
  20.    
  21.   
  22.    

 

画布里面有一个函数叫做drawnode函数，这个函数接受的参数包括一个聚类，还有他的位置，当然画画的画笔，然后缩放因子，以及博客名称。这个函数是整个画图中的核心函数，所以请认真研究它。

[python] view plain copy
  1. def drawnode(draw,clust,x,y,scaling,labels):  
  2.     if clust.id<0:  
  3.         h1=getheight(clust.left)*20#两个分支的高度  
  4.         h2=getheight(clust.right)*20  
  5.   
  6.         top=y-(h1+h2)/2#如果是第一次画点的话，top居然是最高点，也就是等于0。是上面边界。针对某一个节点，其高度就是左节点的高度加右节点的高度。  
  7.         bottom=y+(h1+h2)/2#这个确实也是下边界。  
  8.   
  9.         #线的长度  
  10.         ll=clust.distance*scaling  
  11.   
  12.         #聚类到其子节点的垂直线  
  13.         draw.line((x,top+h1/2,x,bottom-h2/2),fill=(255,0,0))  
  14.   
  15.         #连接左侧节点的水平线  
  16.         draw.line((x,top+h1/2,x+ll,top+h1/2),fill=(255,0,0))  
  17.   
  18.         #连接右侧节点的水平线  
  19.         draw.line((x,bottom-h2/2,x+ll,bottom-h2/2),fill=(255,0,0))  
  20.   
  21.         #调用函数绘制左右节点  
  22.         drawnode(draw,clust.left,x+ll,top+h1/2,scaling,labels)  
  23.         drawnode(draw,clust.right,x+ll,bottom-h2/2,scaling,labels)  
  24.     else:  
  25.         #如果这是一个叶节点，则绘制节点的标签。其实现在突然觉得这种思路非常好。绘制的是标签，本题中绘制的博客名字  
  26.         draw.text((x+5,y-7),labels[clust.id],(0,0,0))  
  27.           



执行代码如下所示：

[python] view plain copy
  1. blognames,words,data=readfile('blogdata.txt')  
  2. clust=hcluster(data)  
  3. drawdendrogram(clust,blognames,jpeg='分级聚类图.jpg')  



最后我们可以得到一张图，如下所示。由于msdn限制的宽度的像素，真心想看的话，右键保存既可以。


总结

内容并不难。原理不难，难在画最后那个树状图。

实际上关键的还是还是相似度计算，用相似度来判断是否属于一个类。这并不难以接受。关于分级聚类，就学习到这里吧。

由于我暂时没发现和项目的关系有多大，所以没太多思考。我唯一想到的和项目有关系的部分，就是我想在用户选艺人或者标签的时候，对出现的艺人或者标签做一个聚类分析，不让要一页里出现太多相似的艺人或者标签。

 

代码

[python] view plain copy
  1. from PIL import Image,ImageDraw  
  2. # -*- coding: cp936 -*-  
  3. def readfile(filename):  
  4.     lines=[line for line in file(filename)]  
  5.   
  6.     #第一行是列标题，也就是被统计的单词是哪些  
  7.     colnames=lines[0].strip().split('\t')[1:]#之所以从1开始，是因为第0列是用来放置博客名了  
  8.     rownames=[]  
  9.     data=[]  
  10.     for line in lines[1:]:#第一列是单词，但二列开始才是对不同的单词的计数  
  11.         p=line.strip().split('\t')  
  12.         #每行都是的第一列都是行名  
  13.         rownames.append(p[0])  
  14.         #剩余部分就是该行对应的数据  
  15.         data.append([float(x) for x in p[1:]])#data是一个列表，这个列表里每一个元素都是一个列表，每一列表的元素就是对应了colnames[]里面的单词  
  16.     return rownames,colnames,data  
  17.   
  18.   
  19. from math import sqrt  
  20. def pearson(v1,v2):  
  21.     #先求和  
  22.     sum1=sum(v1)  
  23.     sum2=sum(v2)  
  24.   
  25.     #求平方和  
  26.     sum1Sq=sum([pow(v,2) for v in v1])  
  27.     sum2Sq=sum([pow(v,2) for v in v2])  
  28.   
  29.     #求乘积之和  
  30.     pSum=sum([v1[i]*v2[i] for i in range(len(v1))])  
  31.   
  32.     #计算pearson相关系数  
  33.     num=pSum-(sum1*sum2/len(v1))  
  34.     den=sqrt((sum1Sq-pow(sum1,2)/len(v1))*(sum2Sq-pow(sum2,2)/len(v1)))  
  35.     if den==0:return 0  
  36.   
  37.     return 1.0-num/den#因为在本题中，我们想要相似度也大的两个元素的距离越近，所以才用1去减它们  
  38.   
  39. #图中每一个点都是一个该类的对象，而其中叶节点显然就是原始数据，而枝节点的数据主要来自其叶节点的均值。  
  40. class bicluster:  
  41.     def __init__(self,vec,left=None,right=None,distance=0.0,id=None):  
  42.         self.left=left  
  43.         self.right=right  
  44.         self.vec=vec#就是词频列表  
  45.         self.id=id  
  46.         self.distance=distance  
  47.   
  48. def hcluster(rows,distance=pearson):  
  49.     distances={}#每计算一对节点的距离值就会保存在这个里面，这样避免了重复计算  
  50.     currentclustid=-1  
  51.   
  52.     #最开始的聚类就是数据集中的一行一行，每一行都是一个元素  
  53.     #clust是一个列表，列表里面是一个又一个biccluster的对象  
  54.     clust=[bicluster(rows[i],id=i) for i in range(len(rows))]  
  55.   
  56.     while len(clust)>1:  
  57.         lowestpair=(0,1)#先假如说lowestpair是0和1号  
  58.         closest=distance(clust[0].vec,clust[1].vec)#同样将0和1的pearson相关度计算出来放着。  
  59.         #遍历每一对节点，找到pearson相关系数最小的  
  60.         for i in range(len(clust)):  
  61.             for j in range(i+1,len(clust)):  
  62.                 #用distances来缓存距离的计算值  
  63.                 if(clust[i].id,clust[j].id) not in distances:  
  64.                     distances[(clust[i].id,clust[j].id)]=distance(clust[i].vec,clust[j].vec)  
  65.                 d=distances[(clust[i].id,clust[j].id)]  
  66.                 if d<closest:  
  67.                     closest=d  
  68.                     lowestpair=(i,j)  
  69.         #找到这个次循环的最小一对后，产生新的枝节点。先计算出这个新的枝节点的词频  
  70.         mergevec=[(clust[lowestpair[0]].vec[i]+clust[lowestpair[1]].vec[i])/2.0 for i in range(len(clust[0].vec))]  
  71.   
  72.         #建立新的聚类  
  73.         newcluster=bicluster(mergevec,left=clust[lowestpair[0]],right=clust[lowestpair[1]],distance=closest,id=currentclustid)  
  74.   
  75.         #不在初始集合中的聚类，其id设置为负数  
  76.         currentclustid-=1  
  77.         del clust[lowestpair[1]]  
  78.         del clust[lowestpair[0]]  
  79.         clust.append(newcluster)  
  80.   
  81.     #当只有一个元素之后，就返回，这个节点相当于根节点  
  82.     return clust[0]  
  83.   
  84.   
  85. #我们急于验证上面的函数，所以先写一个简单的函数来打印节点，形式是和文件系统层级结构相关。  
  86. def printclust(clust,labels=None,n=0):  
  87.     #利用缩进来建立层级布局  
  88.     for i in range(n):print ' ',  
  89.     if clust.id<0:  
  90.         #负数代表这是一个分支  
  91.         print '-'  
  92.     else:  
  93.         #正数代表这是一个叶节点  
  94.         if labels==None: print clust.id  
  95.         else:print labels[clust.id]  
  96.     if clust.left!=None:printclust(clust.left,labels=labels,n=n+1)  
  97.     if clust.right!=None:printclust(clust.right,labels=labels,n=n+1)      
  98.   
  99. #blognames,words,data=readfile('blogdata.txt')  
  100. #clust=hcluster(data)  
  101. #printclust(clust,labels=blognames)  
  102.   
  103.   
  104. def getheight(clust):  
  105.     #这是一个叶节点吗？若是，则高度为1  
  106.     if clust.left==None and clust.right ==None:return 1  
  107.     #否则，高度为每个分支的高度之和  
  108.     return getheight(clust.left)+getheight(clust.right)  
  109.   
  110.   
  111. def getdepth(clust):  
  112.     #一个叶节点的距离是0.0，这是因为叶节点之后就没有了，将其放在最左边也没事  
  113.     if clust.left==None and clust.right ==None:return 0  
  114.   
  115.     #而一个枝节点的距离等于左右两侧分支中距离较大的那一个  
  116.     #加上自身距离：所谓自身距离，与就是某节点与两一节点合并时候的相似度  
  117.     return max(getdepth(clust.left),getdepth(clust.right))+clust.distance  
  118.   
  119. def drawdendrogram(clust,labels,jpeg='clusters.jpg'):  
  120.     #高度和宽度  
  121.     h=getheight(clust)*20  
  122.     w=1200  
  123.     depth=getdepth(clust)  
  124.   
  125.     #我们固定了宽度，所以需要对每一个节点的横向摆放做一个缩放，而不像高度一样，每一个叶节点都分配20  
  126.     scaling=float(w-150)/depth  
  127.   
  128.     #新建一张白色的背景图片  
  129.     img=Image.new('RGB',(w,h),(255,255,255))  
  130.     draw=ImageDraw.Draw(img)  
  131.   
  132.     draw.line((0,h/2,10,h/2),fill=(255,0,0))#仅仅是画了一个起点  
  133.       
  134.     #画第一个节点  
  135.     drawnode(draw,clust,10,(h/2),scaling,labels)  
  136.     img.save(jpeg,'JPEG')  
  137.   
  138. def drawnode(draw,clust,x,y,scaling,labels):  
  139.     if clust.id<0:  
  140.         h1=getheight(clust.left)*20#两个分支的高度  
  141.         h2=getheight(clust.right)*20  
  142.   
  143.         top=y-(h1+h2)/2#如果是第一次画点的话，top居然是最高点，也就是等于0。是上面边界。针对某一个节点，其高度就是左节点的高度加右节点的高度。  
  144.         bottom=y+(h1+h2)/2#这个确实也是下边界。  
  145.   
  146.         #线的长度  
  147.         ll=clust.distance*scaling  
  148.   
  149.         #聚类到其子节点的垂直线  
  150.         draw.line((x,top+h1/2,x,bottom-h2/2),fill=(255,0,0))  
  151.   
  152.         #连接左侧节点的水平线  
  153.         draw.line((x,top+h1/2,x+ll,top+h1/2),fill=(255,0,0))  
  154.   
  155.         #连接右侧节点的水平线  
  156.         draw.line((x,bottom-h2/2,x+ll,bottom-h2/2),fill=(255,0,0))  
  157.   
  158.         #调用函数绘制左右节点  
  159.         drawnode(draw,clust.left,x+ll,top+h1/2,scaling,labels)  
  160.         drawnode(draw,clust.right,x+ll,bottom-h2/2,scaling,labels)  
  161.     else:  
  162.         #如果这是一个叶节点，则绘制节点的标签。其实现在突然觉得这种思路非常好。绘制的是标签，本题中绘制的博客名字  
  163.         draw.text((x+5,y-7),labels[clust.id],(0,0,0))  
  164.           
  165. blognames,words,data=readfile('blogdata.txt')  
  166. clust=hcluster(data)  
  167. drawdendrogram(clust,blognames,jpeg='分级聚类图.jpg')  
阅读全文
0 0
linux内核调试工具 linux内核调试工具
原创粉丝点击
热门IT博客
判断矩阵一致性检验判断矩阵一致性检验
数据库王珊萨第四版pdf数据库王珊萨第四版pdf
r语言按列读取csv数据
学电脑编程哪里好
wake on lan for mac
adobe cc 2015 mac
php签名验证 源码
天下3玉玑子捏脸数据
空调遥控器软件
淘宝店怎么设置佣金
java socket视频教程
怎样清除township数据
淘宝佣金怎么计算
php function exists
赛尔网络官网
java基础笔试题及答案
window phone10软件
linux cpu绑核
退货淘宝id是什么意思
基站定位数据
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 白甘蔗 甘蔗发红 梦见吃甘蔗 甘蔗app 甘蔗是水果 闽侯甘蔗 广西甘蔗 甘蔗的功效 甘蔗怎么吃 黑甘蔗图片 甘蔗的读音 甘蔗价格 甘蔗批发 甘蔗图 甘蔗产地 甘蔗怎么种 甘蔗批发价 甘蔗英语 甘蔗的作用 甘蔗英文 甘蔗种子 甘蔗种 甘蔗报价 种甘蔗 批发甘蔗 甘蔗水 甘蔗苗 甘蔗开沟机 甘蔗补血吗 梦到吃甘蔗 红心甘蔗 绿皮甘蔗 甘蔗种植机 甘蔗怎么读 梦到甘蔗 种植甘蔗 怎么种甘蔗 水果甘蔗 甘蔗林小娟 细甘蔗 甘蔗渣

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里