标签传递算法：java版

最新推荐文章于 2024-04-14 15:14:44 发布
最新推荐文章于 2024-04-14 15:14:44 发布
阅读量940 收藏 1
点赞数 1
分类专栏： 机器学习 Java 文章标签： java 标签 算法

标签传递算法：java版


原文：smly/java-labelpropagation: java implementation of labelpropagation

java-labelpropagation

Java implementation of GFHF ([Zhu and Ghahramani, 2002]).

Iterate
1. \hat{Y}^{(t+1)} \leftArrow D^{-1} W \hat{Y}^{(t)}
2. \hat{Y}^{(t+1)}_l \leftArrow Y_l
until convergence to \hat{Y}^{(\infty)}
Usage

  $ mvn compile
  $ mvn package
  $ cat data/sample.json
  [2, 1, [[1, 1.0], [3, 1.0]]]
  [3, 0, [[1, 1.0], [2, 1.0], [4, 1.0]]]
  [4, 0, [[3, 1.0], [5, 1.0], [8, 1.0]]]
  [5, 0, [[4, 1.0], [6, 1.0], [7, 1.0]]]
  [6, 2, [[5, 1.0], [7, 1.0]]]
  [7, 0, [[5, 1.0], [6, 1.0]]]
  [8, 0, [[4, 1.0], [9, 1.0]]]
  [9, 2, [[8, 1.0]]]
  $ java -classpath target/labelprop-1.0-SNAPSHOT-jar-with-dependencies.jar \
     org.ooxo.LProp \
     -a GFHF \
     -m 100 \
     -e 10e-5 \
     data/sample.json
  Number of vertices:            9
  Number of class labels:        2
  Number of unlabeled vertices:  6
  Numebr of labeled vertices:    3
  eps:                          1e-5
  max iteration:                100
  .............................
  iter = 29, eps = 9.918212890613898E-5
  [1,1,[1,0.8706],[2,0.1294]]
  [2,1,[1,1.0000],[2,0.0000]]
  [3,1,[1,0.7412],[2,0.2588]]
  [4,2,[1,0.3529],[2,0.6470]]
  [5,2,[1,0.1412],[2,0.8588]]
  [6,2,[1,0.0000],[2,1.0000]]
  [7,2,[1,0.0706],[2,0.9294]]
  [8,2,[1,0.1765],[2,0.8235]]
  [9,2,[1,0.0000],[2,1.0000]]

References

Chapelle O, Schölkopf B and Zien A: Semi-Supervised Learning, 508, MIT Press, Cambridge, MA, USA, (2006).
http://mitpress.mit.edu/catalog/item/default.asp?ttype=2&tid=11015

本地测试

E:\workspace\java\java-labelpropagation

git clone https://github.com/smly/java-labelpropagation.git
mvn clean package
java -classpath target/labelprop-1.0-SNAPSHOT-jar-with-dependencies.jar org.ooxo.LProp -a GFHF -m 100 -e 10e-5 data/sample.json

数据集

[vertexId, vertexLabel, edges[destVertexId, edgeWeight]]
如果vertexLabel == 0，则表示未打标签。destVertexId连接的另一个节点，edgeWeight边的权重。

[1, 0, [[2, 1.0], [3, 1.0]]]
[2, 1, [[1, 1.0], [3, 1.0]]]
[3, 0, [[1, 1.0], [2, 1.0], [4, 1.0]]]
[4, 0, [[3, 1.0], [5, 1.0], [8, 1.0]]]
[5, 0, [[4, 1.0], [6, 1.0], [7, 1.0]]]
[6, 2, [[5, 1.0], [7, 1.0]]]
[7, 0, [[5, 1.0], [6, 1.0]]]
[8, 0, [[4, 1.0], [9, 1.0]]]
[9, 2, [[8, 1.0]]]

LPAlgorithm

void processLine(String line) {
    try {
        // [vertexId, vertexLabel, edges]
        // unlabeled vertex if vertexLabel == 0
        // i.e. [2, 1, [[1, 1.0], [3, 1.0]]]
        JSONArray json = new JSONArray(line);
        Long vertexId = json.getLong(0);
        Long vertexLabel = json.getLong(1);
        JSONArray edges = json.getJSONArray(2);
        ArrayList<Edge> edgeArray = new ArrayList<Edge>();
        vertexLabelMap.put(vertexId, vertexLabel);
        for (int i = 0; i < edges.length(); ++i) {
            JSONArray edge = edges.getJSONArray(i);
            Long destVertexId = edge.getLong(0);
            Double edgeWeight = edge.getDouble(1);
            edgeArray.add(new Edge(vertexId, destVertexId, edgeWeight));
        }
        vertexAdjMap.put(vertexId, edgeArray);
    } catch (JSONException e) {
        throw new IllegalArgumentException(
                "Coundn't parse vertex from line: " + line, e);
    }
}

处理一行数据，将标签存到vertexLabelMap，将节点和边的情况存到vertexAdjMap。

vertexLabelMap

[vertexId, vertexLabel]

vertexAdjMap

[vertexId, [vertexId, destVertexId, edgeWeight]]

loadJSON

vertexAdjMap和vertexInAdjMap的区别在哪里？

掉头

//vertexAdjMap
1:[{"dest":2,"src":1,"weight":1},{"dest":3,"src":1,"weight":1}]
//vertexInAdjMap
1:[{"dest":1,"src":2,"weight":1},{"dest":1,"src":3,"weight":1}]
// initialize vertexInAdjMap
for (Long vertexId : vertexAdjMap.keySet()) {
    if (! vertexInAdjMap.containsKey(vertexId)) {
        vertexInAdjMap.put(vertexId, new ArrayList<Edge>());
    }
}
// setup vertexInAdjMap
for (Long vertexId : vertexAdjMap.keySet()) {
    for (Edge e : vertexAdjMap.get(vertexId)) {
        vertexInAdjMap.get(e.getDest()).add(e);
    }
}

根据每个节点的权重计算度vertexDegMap

// setup vertexDegMap
for (Long vertexId : vertexAdjMap.keySet()) {
    double degree = 0;
    if (vertexDegMap.containsKey(vertexId)) {
        degree = vertexDegMap.get(vertexId);
    }
    for (Edge e : vertexAdjMap.get(vertexId)) {
        degree += e.getWeight();
    }
    vertexDegMap.put(vertexId, degree);
}

vertexDegMap
{1=2.0, 2=2.0, 3=3.0, 4=3.0, 5=3.0, 6=2.0, 7=2.0, 8=2.0, 9=1.0}

标签

// setup vertexFMap
Set<Long> vSet = vertexLabelMap.keySet();
Iterator<Long> it = vSet.iterator();
Set<Long> lSet = new TreeSet<Long>();
while (it.hasNext()) {

    Long l = vertexLabelMap.get(it.next());
    lSet.add(l);
    vertexSize++;
}
Iterator<Long> lSetIter = lSet.iterator();
int labelEnum = 0;
while (lSetIter.hasNext()) {
    Long l = lSetIter.next();
    if (l.intValue() == 0) continue;
    labelIndexMap.put(l, new Long(labelEnum));
    labelEnum++;
}
labelSize = labelEnum;
it = vSet.iterator();
labeledSize = 0;
while (it.hasNext()) {
    Long v = it.next();
    ArrayList<Double> arr = new ArrayList<Double>(labelEnum);
    Long l = vertexLabelMap.get(v);
    if (l.intValue() == 0) {
        // unlabeled
        for (int i = 0; i < labelSize; ++i) {
            arr.add(0.0);
        }
    } else {
        // labeled
        labeledSize++;
        int ix = labelIndexMap.get(vertexLabelMap.get(v)).intValue();
        for (int i = 0; i < labelSize; ++i) {
            arr.add((i == ix) ? 1.0 : 0.0);
        }
    }
    vertexFMap.put(v, arr);
}
TreeSet

Java 集合系列17之 TreeSet详细介绍(源码解析)和使用示例 - 如果天空不死 - 博客园
java TreeSet的使用 - you_off3的专栏 - CSDN博客

Set<Long> lSet = new TreeSet<Long>();
TreeSet:它可以给Set集合中的元素进行指定方式的排序。保证元素唯一性的方式：通过比较的结果是否为0。底层数据结构是：二叉树。TreeSet是基于TreeMap实现的。TreeSet中的元素支持2种排序方式：自然排序 或者 根据创建TreeSet 时提供的 Comparator 进行排序。这取决于使用的构造方法。

构建vSet，lSet和labelIndexMap
Set<Long> vSet = vertexLabelMap.keySet();
Iterator<Long> it = vSet.iterator();
Set<Long> lSet = new TreeSet<Long>();
while (it.hasNext()) {

    Long l = vertexLabelMap.get(it.next());
    lSet.add(l);
    vertexSize++;
}
Iterator<Long> lSetIter = lSet.iterator();
int labelEnum = 0;
while (lSetIter.hasNext()) {
    Long l = lSetIter.next();
    if (l.intValue() == 0) continue;
    labelIndexMap.put(l, new Long(labelEnum));
    labelEnum++;
}
labelSize = labelEnum;

vSet
[1, 2, 3, 4, 5, 6, 7, 8, 9]
lSet
[0, 1, 2]
labelIndexMap是对label进行编号，1=0表示标签1放在第0个位置上。
{1=0, 2=1}

构建vertexFMap
it = vSet.iterator();
labeledSize = 0;
while (it.hasNext()) {
    Long v = it.next();
    ArrayList<Double> arr = new ArrayList<Double>(labelEnum);
    Long l = vertexLabelMap.get(v);
    if (l.intValue() == 0) {
        // unlabeled
        for (int i = 0; i < labelSize; ++i) {
            arr.add(0.0);
        }
    } else {
        // labeled
        labeledSize++;
        int ix = labelIndexMap.get(vertexLabelMap.get(v)).intValue();
        for (int i = 0; i < labelSize; ++i) {
            arr.add((i == ix) ? 1.0 : 0.0);
        }
    }
    vertexFMap.put(v, arr);
}

vertexFMap
{1=[0.0, 0.0], 2=[1.0, 0.0], 3=[0.0, 0.0], 4=[0.0, 0.0], 5=[0.0, 0.0], 6=[0.0, 1.0], 7=[0.0, 0.0], 8=[0.0, 0.0], 9=[0.0, 1.0]}

showDetail

void showDetail() {
    System.out.println("Number of vertices:            " + vertexSize);
    System.out.println("Number of class labels:        " + labelSize);
    System.out.println("Number of unlabeled vertices:  " + (vertexSize - labeledSize));
    System.out.println("Numebr of labeled vertices:    " + labeledSize);
}

GFHF

iter

处理未标签的节点nextVertexFMap

// for all vertex
double diff = 0.0;
for (Long vertexId : vertexFMap.keySet()) {
    if (vertexLabelMap.get(vertexId) != 0) continue; // skip labeled
    // update F(vertexID) ... vetexFMap
    ArrayList<Double> nextFValue = new ArrayList<Double>();
    ArrayList<Double> fValues = vertexFMap.get(vertexId);
    for (int l = 0; l < labelSize; ++l) {
        // update f_l(vertexId)
        double fValue = 0.0;
        for (Edge e : vertexInAdjMap.get(vertexId)) {
            double w = e.getWeight();
            long src = e.getSrc();
            double deg = vertexDegMap.get(vertexId);
            fValue += vertexFMap.get(src).get(l) * (w / deg);
            System.out.println("(src,dst): " + src + "->" + vertexId + ", value = (" + fValue +"), deg = " + deg + ", label = " + l);
        }
        nextFValue.add(fValue);
        if (vertexLabelMap.get(vertexId) == 0) {
            diff += ((fValue > fValues.get(l)) ? fValue - fValues.get(l) : fValues.get(l) - fValue);
        }
    }
    //System.out.println(nextFValue);
    nextVertexFMap.put(vertexId, nextFValue);
    //System.out.println("----");
}
value的值

fValue += vertexFMap.get(src).get(l) * (w / deg);

(src,dst): 2->1, value = (0.5), deg = 2.0, label = 0
(src,dst): 3->1, value = (0.5), deg = 2.0, label = 0
(src,dst): 2->1, value = (0.0), deg = 2.0, label = 1
(src,dst): 3->1, value = (0.0), deg = 2.0, label = 1
结果nextVertexFMap

{1=[0.5, 0.0], 3=[0.3333333333333333, 0.0], 4=[0.0, 0.0], 5=[0.0, 0.3333333333333333], 7=[0.0, 0.5], 8=[0.0, 0.5]}

将已标签的节点回写到nextVertexFMap

// fix labeled vertex
for (Long vertexId : vertexLabelMap.keySet()) {
    if (vertexLabelMap.get(vertexId) == 0) continue; // 0 means unlabeled vertex
    nextVertexFMap.put(vertexId, vertexFMap.get(vertexId));
}

最后将nextVertexFMap赋值给vertexFMap

vertexFMap = nextVertexFMap;

nextVertexFMap
vertexFMap
{1=[0.5, 0.0], 2=[1.0, 0.0], 3=[0.3333333333333333, 0.0], 4=[0.0, 0.0], 5=[0.0, 0.3333333333333333], 6=[0.0, 1.0], 7=[0.0, 0.5], 8=[0.0, 0.5], 9=[0.0, 1.0]}

循环多次结果

vertexFMap
{1=[0.8705767912004067, 0.12939269122146832], 2=[1.0, 0.0], 3=[0.7411612117974713, 0.25880064122987234], 4=[0.3529182882869945, 0.6470206765567554], 5=[0.14116121180087424, 0.8588006412264694], 6=[0.0, 1.0], 7=[0.0705767912042349, 0.92939269121764], 8=[0.1764553294462316, 0.8235065235811121], 9=[0.0, 1.0]}

debug

void debug() {
    ArrayList<Long> labels = new ArrayList<Long>(labelSize);
    for (Long label : labelIndexMap.keySet()) {
        labels.add(labelIndexMap.get(label).intValue(), label);
    }
    for (Long vertexId : vertexFMap.keySet()){
        ArrayList<Double> arr = vertexFMap.get(vertexId);
        System.out.printf("[%d,", vertexId);
        ByteArrayOutputStream buff = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(buff);
        double maxFVal = 0.0;
        int maxFValIx = 0;
        for (int i = 0; i < labelSize; ++i) {
            double fval = arr.get(i);
            if (fval > maxFVal) {
                maxFVal = fval;
                maxFValIx = i;
            }
            ps.printf("[%d,%.04f]", labels.get(i), arr.get(i));
            ps.printf(i != labelSize - 1 ? "," : "]\n");
        }
        System.out.print(labels.get(maxFValIx) + "," + buff.toString());
    }
}

比较vertexFMap中的值。哪个大，则标标记为对应标签。

例如

1=[0.8705767912004067, 0.12939269122146832]

输出

[1,1,[1,0.8706],[2,0.1294]]

最终结果输出
[1,1,[1,0.8706],[2,0.1294]]
[2,1,[1,1.0000],[2,0.0000]]
[3,1,[1,0.7412],[2,0.2588]]
[4,2,[1,0.3529],[2,0.6470]]
[5,2,[1,0.1412],[2,0.8588]]
[6,2,[1,0.0000],[2,1.0000]]
[7,2,[1,0.0706],[2,0.9294]]
[8,2,[1,0.1765],[2,0.8235]]
[9,2,[1,0.0000],[2,1.0000]]

1,2,3标记为1
4,5,6,7,8,9标记为2

夺宝奇兵
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
AI人工智能深度学习算法：在精准医疗中的应用
光剑书架上的书
04-21 955
1.背景介绍 随着科技的进步和数据的累积，人工智能（Artificial Intelligence，AI）和深度学习（Deep Learning）已经成为了我们生活中不可或缺的一部分。这些技术不仅在科研，工业，商业等领域发挥了极大的作用，而且在医疗健康领域也发挥了重要作用，尤其是在精准医疗中。在本文中，我们将深入探讨AI和深度学习算法在精准医疗中的应用
标签传播算法LPA
01-17
标签传播算法，能快速准确的识别网络社团，效率高，接近线性，但是对于二分图会产生震荡现象
java 标签传播算法_Label Propagation Algorithm LPA 标签传播算法解析及matlab代码实现...
weixin_29523709的博客
03-05 409
LPA算法的思路：首先每个节点有一个自己特有的标签，节点会选择自己邻居中出现次数最多的标签，如果每个标签出现次数一样多，那么就随机选择一个标签替换自己原始的标签，如此往复，直到每个节点标签不再发生变化，那么持有相同标签的节点就归为一个社区。算法优点：思路简单，时间复杂度低，适合大型复杂网络。算法缺点：众所周知，划分结果不稳定，随机性强是这个算法致命的缺点。体现在：(1)更新顺序。节点标签更新顺序随...
java 标签传播算法_lpa标签传播算法解说及代码实现
weixin_39531834的博客
02-19 428
package lpa;import java.util.Arrays;import java.util.HashMap;import java.util.Map;public class LPA {public static float sigma = 1;public static int tag_num = 2;public static void main(String[] args) {...
Java实现利用标签相似度匹配用户，匹配度由上到下（ 编辑距离算法实现）
qq_55983332的博客
04-11 1056
1.首先就是编辑距离算法，此处匹配的是两个字符串，由于标签不止一个，我们需要进行适当的修改。我的项目是每个用户都会有标签，设置开启匹配模式，也就是说展示匹配之后的用户，实现方法如下。其中num这个参数指的是你所要展示的条数，就是匹配出来的之后展示的由大到小前几条。serviceimpl层。controller层。
java正则表达式 匹配标签_Java正则表达式如何匹配特定html标签内的内容
weixin_29952383的博客
02-25 627
如题：使用正则表达式，怎么匹配特定html标签内的内容。比如，对于如下文本串：... ignored contentprefix contentinner contentpostfix content... ignored content我们要提取出标签内的内容: inner content(这里的html标签可以换成任何其它的标签，比如标签)这里引入正则表达式的group概念：详细点击文章查看比...
SVM 算法 java版本
03-01
Encog是开源的Java库，提供了多种机器学习算法，包括SVM。它的设计目标是简化神经网络和机器学习的实现过程。Encog提供了丰富的API，允许开发者轻松地创建、训练和应用模型。在"algorithmApi.java"中，可能包含了...
AES加密算法（java实现）.zip_aes java_cmM0 解密_java aes加密 demo_js aes加密算法_
09-20
在JavaScript中，你需要将Java生成的密钥以Base64编码的方式传递，然后在JS端进行解码并用于加密或解密。 标签中提到的`cmm0_解密`可能指的是某种特定的解密方式或者工具，但没有提供足够的信息来详细解释。`java_...
Java版-剑指offer数据结构与算法 视频教程 下载 百度网盘链接4.zip
最新发布
06-19
《Java版-剑指offer数据结构与算法 视频教程 下载 百度网盘链接4.zip》这个压缩包文件，显然包含了一套专门针对Java编程语言的数据结构与算法的视频教程。在学习编程，尤其是Java开发时，掌握数据结构与算法是至关...
eulerproject:java8 https中的euler项目的日常解决方案
05-08
3. **Lambda表达式**：Java 8引入的关键特性之一，它简化了函数式编程，允许将函数作为一等公民进行传递和操作。在解决欧拉项目问题时，lambda可以用于创建简洁的回调函数，简化代码逻辑。 4. **Stream API**：Java...
相似度算法;人群标签推荐
06-12
a=[01,02,04,06],b=[09.08,04,07].计算a,b的相似度。用户门户网站推荐,根据个人行为推荐。
java匹配算法_java实现多模匹配算法
weixin_32896083的博客
02-12 245
这个是好几年前写的了.都统一放到cnblogs上面.--------------------------------Node ----------------------------------package com;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util....
java模式匹配算法_java 中模式匹配算法-KMP算法实例详解
weixin_42148975的博客
02-12 213
java 中模式匹配算法-KMP算法实例详解发布时间：2020-08-26 02:51:53来源：脚本之家阅读：119作者：lqhjava 中模式匹配算法-KMP算法实例详解朴素模式匹配算法的最大问题就是太低效了。于是三位前辈发表了一种KMP算法，其中三个字母分别是这三个人名的首字母大写。简单的说，KMP算法的对于主串的当前位置不回溯。也就是说，如果主串某次比较时，当前下标为i,i之前的字符和子串...
java 标记_java的标记算法
weixin_39987138的博客
02-12 260
1、三色标记法(1)基本算法：要找出存活对象，根据可达性分析，从GC Roots开始进行遍历访问，可达的则为存活对象。(2)三色：我们把遍历对象图过程中遇到的对象，按“是否访问过”这个条件标记成以下三种颜色1)白色：尚未访问过。2)黑色：本对象已访问过，而且本对象 引用到 的其他对象 也全部访问过了。3)灰色：本对象已访问过，但是本对象 引用到 的其他对象 尚未全部访问完。全部访问后，会转换为黑色...
数据标签
java
04-03 1040
action标签,可以允许在jsp页面中直接调用Action,在调用Action时候,可以指定需要被调用的Action的name和namespace. 如果指定了executeResult参数的属性值为true,该标签会把Action的处理结果(视图资源)包含到本页面中.  使用action标签指定属性有:      id: 可选属性,作为该Action的引用ID       name:必
Label Propagation算法Giraph实现
cloudeagle_bupt的专栏
08-18 795
package org.apache.giraph.examples.lp; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.List; import org.apache.giraph.comm.WorkerClientRequestP
java实现暴力匹配算法详解
mischen520的博客
12-08 612
从长字符串的第一个字符开始，判断是否和子字符串的第一个字符相等，如果相等，则在比较后面的字符。循环结束后通过判断指向子字符串的索引大小判断是否匹配到，即如果匹配到，则索引大小应该为子字符串长度大小，否则就没有匹配到。如果后边的字符匹配不成功，则重置长字符串索引为当前开始索引的下一个，重置子字符串索引为0，重复前边的步骤。如果第一个字符就不相等，则通过指针后移依次判断长字符串后边的字符是否和第一个字符相等，直到字符串末尾。一旦在长字符串中匹配到子字符串的第一个字符，就依次再比较后边的字符。
预处理数据打标签相关工具
dingding5205205200的博客
05-25 286
1、java中文分词工具 List<Term> terms = ToAnalysis.parse(content); 　　 转载于:https://www.cnblogs.com/learningJAVA/p/9089990.html
LPA图标签传递算法
kiwi_Fung的博客
05-26 2765
1. 简述 本文提出一种迭代的标签传递算法，利用没有标记的数据来帮助已经标记的数据来进行分类。另外利用基于启发式的最小生成树来和熵最小化来学习参数。 2. 背景 在监督学习当中，我们会有大量已经标记的数据，这样我们就可以很轻松的学习到分类的信息以及依赖的特征。但是当我们只有少量已经标记的数据，而大多数都是没有被标记的话，那么我们就没有办法像监督学习那样，比较轻易的获得分类所依赖的特征。 但...
标签传播算法：连接未标记与标记数据的桥梁
chen的博客
04-14 1155
标签传播（Label Propagation）是一种半监督学习方法，用于数据分类。它特别适合于那些标签稀缺的情况，即大部分数据没有标签，少部分数据有标签。标签传播算法利用数据的相似性将已知的标签信息传播到未标记的数据中。这种方法在和分析中特别有用。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值