聚类算法效果评估entropy purity nmi

1.数据管理脚本:原始文件格式id\tclusterId\tgoldstandardId

DataManagement.py

#!/usr/bin/python
import cPickle as p;
import sys;
import re;
if(__name__=="__main__"):
    filename=str(sys.argv[1]);
    preturn=re.compile('(^\s+|\s+$)');
    fidsrc=file(filename,'r');
    clusters={}; #(key,[])
    goldstandards={};#(key,[])
    for line in fidsrc.readlines():
        line=preturn.sub('',line);
        m=line.split('\t');
        #print m
        #s=raw_input('please enter');
        if(len(m)==3):#if 
            if(not clusters.has_key(int(m[1]))):
                clusters[int(m[1])]=[];
                clusters[int(m[1])].append(int(m[0]));
            else:
                 clusters[int(m[1])].append(int(m[0]));
            if(not goldstandards.has_key(int(m[2]))):
                goldstandards[int(m[2])]=[];
                goldstandards[int(m[2])].append(int(m[0]));
            else:
                goldstandards[int(m[2])].append(int(m[0]));
    fidclusters=file(sys.argv[2],'w');
    fidgoldstandards=file(sys.argv[3],'w');
    p.dump(clusters,fidclusters);
    fidclusters.close();
    p.dump(goldstandards,fidgoldstandards);
    fidgoldstandards.close();
    fidsrc.close();
    print '%s has finished!'%sys.argv[0];

EvaluationClusterAlgorithm.py

#!/usr/bin/python
#-*- coding:cp936 -*-
import re;
import cPickle as mypickle;
import sys;
import math;
class Evaluation:
    def __init__(self,clusterfid,goldstandardfid):
        self.clusters=mypickle.load(file(clusterfid));#get the cluster algorithm results
        self.goldstandards=mypickle.load(file(goldstandardfid));#get the gold-standard answers
        tempclusterkeys=self.clusters.keys();
        tempclusterkeys.sort();
        tempgoldstandardkeys=self.goldstandards.keys();
        tempgoldstandardkeys.sort();
        self.k=len(tempclusterkeys);
        self.q=len(tempgoldstandardkeys);
        self.minclusterId=tempclusterkeys[0];#最小聚类ID
        self.maxclusterId=tempclusterkeys[self.k-1];#最大聚类ID
        self.mingoldstandardId=tempgoldstandardkeys[0];
        self.maxgoldstandardId=tempgoldstandardkeys[self.q-1];
        self.coocurrence={};#(clusterId,goldstandardId)=num;store the number of documents shared by clusterId and goldstandardId;
        N1=0;
        N2=0;
        for m in tempclusterkeys:
            N1=N1+len(self.clusters[m]);
        for m in tempgoldstandardkeys:
            N2=N2+len(self.goldstandards[m]);
        if(N1==N2):
            self.N=N1;#num of documents
        else:
            print 'there is a error N1=%d,N2=%d,please reexamine the data source'%(N1,N2);
    def GenerateCoocurrence(self):
        for key_cluster in self.clusters.keys():
            set1=set(self.clusters[key_cluster]);
            for key_gold in self.goldstandards.keys():
                set2=set(self.goldstandards[key_gold]);
                setintersect=set1&set2;
                Num=len(setintersect);
                if(not self.coocurrence.has_key((key_cluster,key_gold))):
                    self.coocurrence[(key_cluster,key_gold)]=Num;
                
            
    def CalPurityForPerCluster(self,clusterId):
        result=0.0;
        NumCollection=[];
        for Id in range(self.mingoldstandardId,self.maxgoldstandardId+1):
            NumCollection.append(self.coocurrence[(clusterId,Id)]);
        NumCollection.sort();
        result=float(NumCollection[len(NumCollection)-1])/float(len(self.clusters[clusterId]));
        
        return result;
    def CalPurity(self):
        result=0.0;
        for clusterId in range(self.minclusterId,self.maxclusterId+1):
            purityPer=self.CalPurityForPerCluster(clusterId);
            result=result+float(len(self.clusters[clusterId]))*purityPer/float(self.N);
        return result;
    def CalEntropyFormula(self,seq):
        result=0.0;
        for elemP in seq:
            if(elemP>0):
                result=result+elemP*math.log(elemP,2);
        return -result;
    def CalEntropyForPerCluster(self,clusterId):
        seq=[];
        result=0;
        for Id in range(self.mingoldstandardId,self.maxgoldstandardId+1):
            Prob=float(self.coocurrence[(clusterId,Id)])/float(len(self.clusters[clusterId]));
            seq.append(Prob);
        result=self.CalEntropyFormula(seq);
        return result;
    def CalEntropy(self):
        result=0;
        for clusterId in range(self.minclusterId,self.maxclusterId+1):
            entropyPer=self.CalEntropyForPerCluster(clusterId);
            result=result+float(len(self.clusters[clusterId]))*entropyPer/float(self.N);
        return result;
    def CalMutualInformation(self):
        result=0.0;
        for clusterId in range(self.minclusterId,self.maxclusterId+1):
            N_c=len(self.clusters[clusterId]);
            for goldId in range(self.mingoldstandardId,self.maxgoldstandardId+1):
                N_g=len(self.goldstandards[goldId]);
                N_cg=self.coocurrence[(clusterId,goldId)];
                part=float(self.N)*float(N_cg)/(N_c*N_g);
                if(part>0):
                    result=result+(float(N_cg)/float(self.N))*math.log(part,2);
        return result;
    def CalNMI(self):
        NMI=0.0;
        seq1=[];#calculate the entropy of automated clusters
        seq2=[];#calculate the entropy of gold-standard clusters
        for clusterId in range(self.minclusterId,self.maxclusterId+1):
            Prob=float(len(self.clusters[clusterId]))/float(self.N);
            seq1.append(Prob);
        for goldId in range(self.mingoldstandardId,self.maxgoldstandardId+1):
            Prob=float(len(self.goldstandards[goldId]))/float(self.N);
            seq2.append(Prob);
        H1=self.CalEntropyFormula(seq1);
        H2=self.CalEntropyFormula(seq2);
        IG=self.CalMutualInformation();
        NMI=2*IG/(H1+H2);
        return NMI;
        
        
        
if(__name__=="__main__"):
    clusterAddress=str(sys.argv[1]);
    goldAddress=str(sys.argv[2]);
    e= Evaluation(clusterAddress,goldAddress);
    print '聚类算法产生簇个数%d'%e.k;
    print  '人工标注的标准答案中簇个数%d'%e.q;
    print '文档总数%d'%e.N;
    print '最小聚类ID标号%d'%e.minclusterId;
    print '最大聚类ID标号%d'%e.maxclusterId;
    print '标准答案中最小聚类ID标号%d'%e.mingoldstandardId;
    print '标准答案中最大聚类ID标号%d'% e.maxgoldstandardId;
    e.GenerateCoocurrence();
    #for m in e.coocurrence:
       # print m;
       # print e.coocurrence[m];
       # print '***************************'
    purity=e.CalPurity();
    print '纯度为%f'% purity;
    #a=[0.2,0.3,0.5,0];
    #print e.CalEntropyFormula(a);
    entropy= e.CalEntropy();
    print '熵为%f'%entropy;
    nmi=e.CalNMI();
    print '归一化互信息为%f'%nmi

   
        

代码调用示意图