java实现Fmeasure计算_聚类结果的评估指标及其JAVA实现

最新推荐文章于 2024-05-11 16:45:29 发布
最新推荐文章于 2024-05-11 16:45:29 发布
阅读量428 收藏
点赞数
文章标签： java实现Fmeasure计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33755379/article/details/114714824
版权

一. 前言

又GET了一项技能。在做聚类算法的时候，由于要评估所提出的聚类算法的好坏，于是需要与一些已知的算法对比，或者用一些人工标注的标签来比较，于是用到了聚类结果的评估指标。我了解了以下几项。

TP:是指被聚在一类的两个量被正确的分类了(即在标准标注里属于一类的两个对象被聚在一类)

TN:是指不应该被聚在一类的两个对象被正确地分开了(即在标准标注里不是一类的两个对象在待测结果也没聚在一类)

FP：指不应该放在一类的对象被错误的放在了一类。(即在标准标注里不是一类，但在待测结果里聚在一类)

FN：指不应该分开的对象被错误的分开了。(即在标准标注里是一类，但在待测结果里没聚在一类)

P = TP + FP

N = TN + FN

1.准确率、识别率：(rank Index)  RI

accuracy = (TP + TN)/(P + N)

2.错误率、误分类率

error rate = (FP + FN)/(P + N)

3.敏感度

sensitivity = TP / P

4.特效性

specificity = TN / N

5.精度

precision = TP  /   (TP + FP)

6.召回率

recall  =  TP  /   (TP  + FN)

7.RI  其实就是  1  的 accuracy

8.F度量

fd89309172c8722546599b47fc5893f9.png

P为precision

R为recall

9.NMI(normalized mutual information)

712f3a1a557e41ba7864785ad2f5aa44.png

10 Jaccard

J = TP  / (TP + F)

二、JAVA实现(未优化)

其中很多重复代码，还没有优化。。。

package others;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import javax.rmi.CORBA.Util;

import org.graphstream.algorithm.measure.NormalizedMutualInformation;

/*function:常用的聚类评价指标有purity, precision, recall， RI 和 F-score,jaccard

* @param:

* @author:Wenbao Li

* @Data:2015-07-13

*/

public class ClusterEvaluation {

public static void main(String[] args){

int[] A = {1,3,3,3,3,3,3,2,1,0,2,0,2,0,2,1,1,0,1,1};

int[] B = {2,2,0,0,0,3,2,2,3,1,3,1,0,1,2,1,0,1,3,3};

double purity = Purity(A,B);

System.out.println("purity\t\t"+purity);

System.out.println("Pre\t\t"+Precision(A,B));

System.out.println("Recall\t\t"+Recall(A,B));

System.out.println("RI(Accuracy)\t\t"+RI(A,B));

System.out.println("Fvalue\t\t"+F_score(A,B));

System.out.println("NMI\t\t"+NMI(A,B));

}

/*

* 计算一个聚类结果的簇的个数，以及每一簇中的对象个数,

*/

public static Map> clusterDistri(int[] A){

Map> clusterD = new HashMap>();

int max = -1;

for(int i = 0;i< A.length;i++){

if(max < A[i]){

max = A[i];

}

}

for(int i = 0;i< A.length;i++){

int temp = A[i];

if(temp < max+1){

if(clusterD.containsKey(temp)){

Set set = clusterD.get(temp);

set.add(i+1);

clusterD.put(temp, set);

}else{

Set set = new HashSet();

set.add(i+1);

clusterD.put(temp, set);

}

}

}

return clusterD;

}

public static double ClusEvaluate(String method,int[] A,int[] B){

switch(method){

case "Purity":

return Purity(A,B);

case "Precision":

return Precision(A,B);

case "Recall":

return Recall(A,B);

case "RI":

return RI(A,B);

case "F_score":

return F_score(A,B);

case "NMI":

return NMI(A,B);

case "Jaccard":

return Jaccard(A,B);

default:

return -1.0;

}

}

public static int[] commNum(Map> A,Map> B){

int[] commonNo = new int[A.size()];

int com = 0;

Iterator>> itA = A.entrySet().iterator();

int i = 0;

while(itA.hasNext()){

Entry> entryA = itA.next();

Set setA = entryA.getValue();

Iterator>> itB = B.entrySet().iterator();

int maxComm = -1;

while(itB.hasNext()){

Entry> entryB = itB.next();

Set setB = entryB.getValue();

int lengthA = setA.size();

Set temp = new HashSet(setA);

temp.removeAll(setB);

int lengthCom = lengthA - temp.size();

if(maxComm < lengthCom){

maxComm = lengthCom;

}

}

commonNo[i] = maxComm;

com = com + maxComm;

i++;

}

return commonNo;

}

/*

* 所有簇分配正确的除以总的。其中B是对比的标准标签。

*/

public static double Purity(int[] A,int[] B){

double value;

Map> clusterA = clusterDistri(A);

Map> clusterB = clusterDistri(B);

int[] commonNo = commNum(clusterA,clusterB);

int com = 0;

for(int i = 0;i

com = com + commonNo[i];

}

value = com*1.0/A.length;

return value;

}

/*

* @param A,B

* @return 精度

*/

public static double Precision(int[] A,int[] B){

double value = 0.0;

Map> clusterA = clusterDistri(A);//得到聚类结果A的类分布

Map> clusterB = clusterDistri(B);//得到聚类B(标准)的类分布

int[] commonNo = commNum(clusterA,clusterB);//得到A中每个簇中聚类正确的数目。

int allP = 0;

int TP = 0;

int FP = 0;

int TN = 0;

int FN = 0;

Iterator>> itA = clusterA.entrySet().iterator();

int i = 0;

while(itA.hasNext()){

Entry> entryA = itA.next();

allP = allP + combination(entryA.getValue().size(),2);

TP = TP + combination(commonNo[i],2);

i++;

}

FP = allP - TP;

itA = clusterA.entrySet().iterator();

while(itA.hasNext()){

Entry> entryA = itA.next();

Iterator>> itA2 = clusterA.entrySet().iterator();

while(itA2.hasNext()){

Entry> entryA2 = itA2.next();

if(entryA != entryA2){

Set s1 = entryA.getValue();

Set s2 = entryA2.getValue();

for(Integer i1 :s1){

for(Integer i2:s2){

if(B[i1-1] != B[i2-1]){

TN++;

}else{

FN++;

}

}

}

}

}

}

double P = TP*1.0/(TP + FP);

return P;

}

/*

* @param A,B

* @return recal召回率

*/

public static double Recall(int[] A,int[] B){

double value = 0.0;

Map> clusterA = clusterDistri(A);//得到聚类结果A的类分布

Map> clusterB = clusterDistri(B);//得到聚类B(标准)的类分布

int[] commonNo = commNum(clusterA,clusterB);//得到A中每个簇中聚类正确的数目。

int allP = 0;

int TP = 0;

int FP = 0;

int TN = 0;

int FN = 0;

Iterator>> itA = clusterA.entrySet().iterator();

int i = 0;

while(itA.hasNext()){

Entry> entryA = itA.next();

allP = allP + combination(entryA.getValue().size(),2);

TP = TP + combination(commonNo[i],2);

i++;

}

FP = allP - TP;

itA = clusterA.entrySet().iterator();

while(itA.hasNext()){

Entry> entryA = itA.next();

Iterator>> itA2 = clusterA.entrySet().iterator();

while(itA2.hasNext()){

Entry> entryA2 = itA2.next();

if(entryA != entryA2){

Set s1 = entryA.getValue();

Set s2 = entryA2.getValue();

for(Integer i1 :s1){

for(Integer i2:s2){

if(B[i1-1] != B[i2-1]){

TN++;

}else{

FN++;

}

}

}

}

}

}

double R = TP * 1.0/(TP + FN);

return R;

}

/*

* @param A,B

* @return RankIndex

*/

public static double RI(int[] A,int[] B){

double value = 0.0;

Map> clusterA = clusterDistri(A);//得到聚类结果A的类分布

Map> clusterB = clusterDistri(B);//得到聚类B(标准)的类分布

int[] commonNo = commNum(clusterA,clusterB);//得到A中每个簇中聚类正确的数目。

int P = 0;

int TP = 0;

int FP = 0;

int TN = 0;

int FN = 0;

Iterator>> itA = clusterA.entrySet().iterator();

int i = 0;

while(itA.hasNext()){

Entry> entryA = itA.next();

P = P + combination(entryA.getValue().size(),2);

TP = TP + combination(commonNo[i],2);

i++;

}

FP = P - TP;

itA = clusterA.entrySet().iterator();

while(itA.hasNext()){

Entry> entryA = itA.next();

Iterator>> itA2 = clusterA.entrySet().iterator();

while(itA2.hasNext()){

Entry> entryA2 = itA2.next();

if(entryA != entryA2){

Set s1 = entryA.getValue();

Set s2 = entryA2.getValue();

for(Integer i1 :s1){

for(Integer i2:s2){

if(B[i1-1] != B[i2-1]){

TN++;

}else{

FN++;

}

}

}

}

}

}

value = (TP + TN)*1.0/(TP + FP + FN + TN);

return value;

}

/*

* F值，是对精度和召回率的平衡，

* @param A:评估对象。B：评估标准；beta：均衡参数

* @return F值

*/

public static double F_score(int[] A,int[] B){

double beta = 1.0;

double value = 0.0;

Map> clusterA = clusterDistri(A);//得到聚类结果A的类分布

Map> clusterB = clusterDistri(B);//得到聚类B(标准)的类分布

int[] commonNo = commNum(clusterA,clusterB);//得到A中每个簇中聚类正确的数目。

int allP = 0;

int TP = 0;

int FP = 0;

int TN = 0;

int FN = 0;

Iterator>> itA = clusterA.entrySet().iterator();

int i = 0;

while(itA.hasNext()){

Entry> entryA = itA.next();

allP = allP + combination(entryA.getValue().size(),2);

TP = TP + combination(commonNo[i],2);

i++;

}

FP = allP - TP;

itA = clusterA.entrySet().iterator();

while(itA.hasNext()){

Entry> entryA = itA.next();

Iterator>> itA2 = clusterA.entrySet().iterator();

while(itA2.hasNext()){

Entry> entryA2 = itA2.next();

if(entryA != entryA2){

Set s1 = entryA.getValue();

Set s2 = entryA2.getValue();

for(Integer i1 :s1){

for(Integer i2:s2){

if(B[i1-1] != B[i2-1]){

TN++;

}else{

FN++;

}

}

}

}

}

}

double P = TP*1.0/(TP + FP);

double R = TP * 1.0/(TP + FN);

value = (beta*beta + 1)*P * R/(beta*beta*P + R);

return value;

}

public static double Jaccard(int[] A,int[] B){

double value = 0.0;

Map> clusterA = clusterDistri(A);//得到聚类结果A的类分布

Map> clusterB = clusterDistri(B);//得到聚类B(标准)的类分布

int[] commonNo = commNum(clusterA,clusterB);//得到A中每个簇中聚类正确的数目。

int allP = 0;

int TP = 0;

int FP = 0;

int TN = 0;

int FN = 0;

Iterator>> itA = clusterA.entrySet().iterator();

int i = 0;

while(itA.hasNext()){

Entry> entryA = itA.next();

allP = allP + combination(entryA.getValue().size(),2);

TP = TP + combination(commonNo[i],2);

i++;

}

FP = allP - TP;

itA = clusterA.entrySet().iterator();

while(itA.hasNext()){

Entry> entryA = itA.next();

Iterator>> itA2 = clusterA.entrySet().iterator();

while(itA2.hasNext()){

Entry> entryA2 = itA2.next();

if(entryA != entryA2){

Set s1 = entryA.getValue();

Set s2 = entryA2.getValue();

for(Integer i1 :s1){

for(Integer i2:s2){

if(B[i1-1] != B[i2-1]){

TN++;

}else{

FN++;

}

}

}

}

}

}

value = TP * 1.0 / (TP + FP + FN);

return value;

}

public static double NMI(int[] A,int[] B){

Map> clusterA = clusterDistri(A);//得到聚类结果A的类分布

Map> clusterB = clusterDistri(B);//得到聚类B(标准)的类分布

Iterator>> itA = clusterA.entrySet().iterator();

Iterator>> itB = clusterB.entrySet().iterator();

Set> partitionF = new HashSet>();

Set> partitionR = new HashSet>();

int nodeCount = B.length;

while(itA.hasNext()){

Entry> entryA = itA.next();

Set setA = entryA.getValue();

partitionF.add(setA);

setA = null;

entryA = null;

}

while(itB.hasNext()){

Entry> entryB = itB.next();

Set setB = entryB.getValue();

partitionR.add(setB);

setB = null;

entryB = null;

}

return computeNMI(partitionF,partitionR,nodeCount);

}

public static double computeNMI(Set> partitionF,

Set> partitionR,int nodeCount) {

int[][] XY = new int[partitionR.size()][partitionF.size()];

int[] X = new int[partitionR.size()];

int[] Y = new int[partitionF.size()];

int i = 0;

int j = 0;

for (Set com1 : partitionR) {

j = 0;

for (Set com2 : partitionF) {

XY[i][j] = intersect(com1, com2);//待测结果第i个簇和标准结果第j个簇的共有元素个数

X[i] += XY[i][j];//待测结果第i个簇与所有标准结果簇的公共元素个数(感觉就是第i个簇的元素个数)

Y[j] += XY[i][j];//标准结果簇第j个簇的元素个数()

j++;

}

i++;

}

int N = nodeCount;

double Ixy = 0;

double Ixy2 = 0;

for (i = 0; i < partitionR.size(); i++) {

for (j = 0; j < partitionF.size(); j++) {

if (XY[i][j] > 0) {

Ixy += ((double) XY[i][j] / N)

* (Math.log((double) XY[i][j] * N / (X[i] * Y[j])) / Math

.log(2.0));

//Ixy2 = (float) (Ixy2 + -2.0D * XY[i][j]

//* Math.log(XY[i][j] * N / X[i] * Y[j]));

}

}

}

//System.out.println(Ixy2);

//double denom = 0.0F;

//for (int ii = 0; ii < X.length; ++ii)

//denom = (double) (denom + X[ii] * Math.log(X[ii] / N));

//for (int jj = 0; jj < Y.length; ++jj) {

//denom = (double) (denom + Y[jj] * Math.log(Y[jj] / N));

//}

//

//System.out.println(denom);

//double M = (Ixy / denom);

//

//return M;

double Hx = 0;

double Hy = 0;

for (i = 0; i < partitionR.size(); i++) {

if (X[i] > 0)

Hx += h((double) X[i] / N);

}

for (j = 0; j < partitionF.size(); j++) {

if (Y[j] > 0)

Hy += h((double) Y[j] / N);

}

double InormXY = Ixy / Math.sqrt(Hx * Hy);

return InormXY;

}

private static double h(double p) {

return -p * (Math.log(p) / Math.log(2.0));

}

/*

* 两个集合的公共元素个数

*/

private static int intersect(Set com1, Set com2) {

int num = 0;

for (Integer v1 : com1) {

if (com2.contains(v1))

num++;

}

return num;

}

/*

* C(m,n)=m取n

*/

public static int combination(int m,int n){

int result = 1;

if(m < n){

return -1;

}

result = factorial(m)/(factorial(n)*factorial(m-n));

return result;

}

public static int factorial(int m){

if((m == 1) || (m == 0)){

return 1;

}else if(m < 0){

return -1;

}else{

return m*factorial(m-1);

}

}

}

5655742.html

卢名雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java实现Fmeasure计算_聚类效果评测-Fmeasure和Accuracy及其Matlab实现
weixin_29775447的博客
02-26 490
聚类结果的好坏，有很多种指标，其中F-Measue即F值是常用的一种，其中包括precision(查准率或者准确率)和recall(查全率或者召回率)。F-Measue是信息检索中常用的评价标准。F-Measue的公式如下：\[{{F}_{\beta }}=\frac{\left( {{\beta }^{2}}+1 \right)P\cdot R}{{{\beta }^{2}}\cdot P+R}...
Java实现世代距离_IGD反转世代距离-多目标优化评价指标概念及实现
weixin_27605509的博客
02-24 854
IGD反转世代距离-多目标优化评价指标概念及实现觉得有用的话,欢迎一起讨论相互学习~ 参考资料多目标进化优化[1]-郑金华老师，邹娟老师著实验室人手一本人人必看的宝藏图书！IGD(Inverted Generational Distance)是常用的可以同时评价算法收敛性和多样性的指标，中文名反转世代距离。从GD到IGD先被提出的用于评价多目标算法收敛性的指标是GD(Generational Di...
java实现Fmeasure计算_Java Evaluation.fMeasure方法代码示例
weixin_39801991的博客
02-26 143
import weka.classifiers.Evaluation; //导入方法依赖的package包/类public void computeSingleRunResults(MethodEvaluation methodEvaluation){Evaluation evaluation = methodEvaluation.getEvaluation();int hamIndex = HA...
java计算股票技术指标之kdj与macd
最新发布
m0_63122693的博客
05-11 574
MACD（Moving Average Convergence Divergence）是一种常用的技术分析工具，它通过计算两个不同周期的移动平均线（MA）的差值来分析股票或其他金融产品的价格趋势。DIF（Difference of Fast and Slow Moving Average）：这是两个不同周期的移动平均线（MA）之间的差值，其中较快的移动平均线减去较慢的移动平均线。MACD的优点在于它能够平滑地处理数据，减少随机波动的影响，从而提供更稳定的趋势分析。
聚类评价指标
05-02
很好的资源，研究聚类的个数是很有用的东西啊 呵呵
类簇 java_JAVA实现聚类指标的计算Purity、NMI、RI、Precision、Recall、F值。
weixin_30306507的博客
02-19 317
第一个：计算NMI的：package clusters;import java.io.*;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;/*** DATE: 16-6-18 TIME: 上午10:00*//*** 参考文献：http://www-nlp.s...
Kmeans.rar_K._java实现Kmeans_聚类KMEANS算法
07-15
用java语言实现的kmeans算法，将n个点分成k个聚类。
nmi.zip_NMI在哪个包里_聚类指标_聚类结果评价_聚类评价指标_评价
07-15
为了评估聚类算法的效果，我们需要使用各种聚类评价指标，其中Non-Mutual Information（NMI）是一个常用且重要的指标。NMI能够衡量两个分类或聚类结果之间的相互信息，从而帮助我们理解它们之间的独立性。 标题中的...
Kmeans-java.zip_JAVA 聚类_k均值聚类 java_聚类KMEANS算法_高斯聚类 JAVA
07-15
本资源“Kmeans-java.zip”提供了一个用Java语言实现的K均值聚类算法，便于开发者理解和应用。 K均值算法的基本思想是通过迭代过程将数据分配到预先设定的K个聚类中，使得每个聚类内部的数据点尽可能接近，而不同...
CollectAnaly.zip_layer cluster_聚类 运行_聚类分析_聚类分析 matlab_聚类结果分析
09-23
本项目"CollectAnaly.zip_layer cluster_聚类 运行_聚类分析_聚类分析 matlab_聚类结果分析"提供了一个五层MATLAB实现的聚类算法，适用于对复杂数据进行层次聚类。 MATLAB是一种强大的编程环境，尤其在数值计算、...
DBscan.rar_DBSCAN_DBSCAN in java_密度聚类 java_密度聚类java_聚类
09-23
6. **结果输出**：最后，输出各个聚类及其对应的点列表。 在Java代码实现中，我们还需要考虑线程安全问题，特别是当处理大规模数据时。可以使用并发数据结构（如ConcurrentHashMap）和并发编程技术（如Fork/Join...
DesigniteJava:检测气味并计算Java代码的指标
05-13
DesigniteJava DesigniteJava是用于用Java编写的代码的代码质量评估工具。 它检测到大量的设计和实现气味。 它还计算许多常用的面向对象的指标。 特征 检测出17种设计气味 命令式抽象 多面抽象 不必要的抽象 未利用的抽象 封装不足 未利用的封装 模块化破损 循环依赖的模块化 模块化不足 集线器式模块化 层次结构破裂 循环层次 深层次 缺少层次结构 多路径层次结构 叛逆阶层 广泛的阶层 检测10种实施气味 构造函数的抽象函数调用 复杂条件 复杂方法 空捕获子句 长标识符 长方法 长参数列表 长声明 幻数 缺少默认值 计算以下面向对象的指标 LOC（代码行-方法和类的粒度） CC（圈复杂度-方法） PC（参数计数-方法） NOF（字段数-类） NOPF（公共字段数-类） NOM（方法数量-类） NOPM（公共方法数量-类） WMC（每类的加权方法-类）
权证各项指标java算法
01-20
1、权证各项指标的算法 2、包括引伸波幅/标准正态分布函数近似计算公式
Java Measure-开源
04-25
度量对象Java库的面向对象标准，用于单位转换，计算，查找等
java 环比_关于java对查询结果进行环比指标计算的代码示例
weixin_39997311的博客
02-15 527
需求想要统计环比指标((本期数量-上期数量)/上期数量*100%) 假设下面是统计9月份的数据 如下所示品牌数量环比Bosh1561311.87%Siemens2278-75.24%问题查询的时候 需要同时查询8月的数据 统计出8月的数量 然后才能进行环比指标的计算{ "count" : 379.0, "brand" : "Bosch", "month" : "2017-08" }{ "count...
java的mape_深度学习-回归问题的评估指标：MAE, MAPE, MSE, RMSE, R2_Score
weixin_39831001的博客
03-05 1824
回归问题常用的评估指标回归问题常用的评估指标包括：MAE, MAPE, MSE, RMSE, R2_Score等。这些评价指标基本都在 sklearn 包中都封装好了，可直接调用。安装 sklearn, 完整的名字是 scikit-learn。pip install -U scikit-learn# 现在最新版是 V0.22.2.post1metricformulamethodMAEsklearn...
java项目质量评估参数_软件项目质量评价方法之一
weixin_36372014的博客
02-26 415
对项目质量进行评价，是对项目上线前的质量把关，而且可以对项目过程中的质量进行动态的监控，便于尽早发现问题，提高项目质量。项目质量评价的一般步骤如下：1、建立项目质量目标；2.定义项目质量维度；3.确定评价模型；4.确定基线数据；5.执行项目质量评价；6.对比目标、采取修正行动。影响软件项目质量的主要因素会在一些环节产生：产品调研、产品需求分析、PRD设计、UC编写，编码、测试、部署等环节及各个环节...
java 指数计算
moyinghui的专栏
12-15 4689
/** * 给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。 */ public static void testGetExponentOfNum() { double base = Math.random(); int exponent = new Random().nex
java 计算auc_信息检索的评价指标(Precision、Recall、F-score、MAP、ROC、AUC)
weixin_28756427的博客
03-05 334
一：Precision、Recall、F-score信息检索、分类、识别、翻译等领域两个最基本指标是召回率(Recall Rate)和准确率(Precision Rate——注意统计学习方法中precision称为精确率，而准确率accuracy是分类正确的样本除以总样本的个数)，召回率也叫查全率，准确率也叫查准率，概念公式：召回率(Recall) = 系统检索到的相关文件 / 系统所有相关的文件...
java 聚类_聚类算法  java实现
06-03
Java中可以使用一些开源的聚类算法库来实现聚类算法，比如： 1. Weka：Weka是一个非常流行的机器学习库，其中包含了多种聚类算法，比如K-Means、DBSCAN等，使用非常方便。 2. Apache Mahout：Mahout是一个大数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值