Java 类名：com.alibaba.alink.operator.batch.huge.HugeMetaPath2VecTrainBatchOp
Python 类名：HugeMetaPath2VecTrainBatchOp

功能介绍

沿着之前random walk的思路往前走，metapath2vec的方法提出了控制随机游走的模式，这样就可以在生成的序列上根据节点类型的不同来控制序列游走，这样也就可以对异质网络（Heterogeneous Networks）进行表征学习。在游走之前需要设定一个metapath，也就是游走时节点类型的模式
metapath2vec: Scalable Representation Learning for Heterogeneous Networks

参数说明

| 名称 | 中文名称 | 描述 | 类型 | 是否必须？ | 取值范围 | 默认值 | | —- | —- | —- | —- | —- | —- | —- |

| metaPath | 游走的模式 | 一般为用字符串表示，例如 “ABDFA” | String | ✓ | | |

| sourceCol | 起始点列名 | 用来指定起始点列 | String | ✓ | | |

| targetCol | 中止点点列名 | 用来指定中止点列 | String | ✓ | | |

| typeCol | 节点类型列名 | 用来指定节点类型列 | String | ✓ | | |

| vertexCol | 节点列名 | 用来指定节点列 | String | ✓ | 所选列类型为 [STRING] | |

| walkLength | 游走的长度 | 随机游走完向量的长度 | Integer | ✓ | | |

| walkNum | 路径数目 | 每一个起始点游走出多少条路径 | Integer | ✓ | | |

| alpha | 学习率 | 学习率 | Double | | | 0.025 |

| batchSize | batch大小 | batch大小, 按行计算 | Integer | | [1, +inf) | |

| isToUndigraph | 是否转无向图 | 选为true时，会将当前图转成无向图，然后再游走 | Boolean | | | false |

| minCount | 最小词频 | 最小词频 | Integer | | | 5 |

| mode | metapath中word2vec的模式，分别为metapath2vec和metapath2vecpp | metapath的模式 | String | | “METAPATH2VEC”, “METAPATH2VECPP” | “METAPATH2VEC” |

| negative | 负采样大小 | 负采样大小 | Integer | | | 5 |

| numCheckpoint | checkPoint 数目 | checkPoint 数目 | Integer | | | 1 |

| numIter | 迭代次数 | 迭代次数，默认为1。 | Integer | | | 1 |

| randomWindow | 是否使用随机窗口 | 是否使用随机窗口，默认使用 | String | | | “true” |

| vectorSize | embedding的向量长度 | embedding的向量长度 | Integer | | [1, +inf) | 100 |

| weightCol | 权重列名 | 权重列对应的列名 | String | | 所选列类型为 [BIGDECIMAL, BIGINTEGER, BYTE, DOUBLE, FLOAT, INTEGER, LONG, SHORT] | null |

| window | 窗口大小 | 窗口大小 | Integer | | | 5 |

代码示例

Python 代码

  1. from pyalink.alink import *
  3. import pandas as pd
  5. useLocalEnv(1)
  7. df_data = pd.DataFrame([
  8.     ["Bob", "Lucy", 1.],
  9.     ["Lucy", "Bob", 1.],
  10.     ["Lucy", "Bella", 1.],
  11.     ["Bella", "Lucy", 1.],
  12.     ["Alice", "Lisa", 1.],
  13.     ["Lisa", "Alice", 1.],
  14.     ["Lisa", "Karry", 1.],
  15.     ["Karry", "Lisa", 1.],
  16.     ["Karry", "Bella", 1.],
  17.     ["Bella", "Karry", 1.]
  18. ])
  19. source =  BatchOperator.fromDataframe(df_data, schemaStr='start string, end string, value double')
  20. nodeType = pd.DataFrame([
  21.     ["Bob", "A"],
  22.     ["Bella", "A"],
  23.     ["Karry", "A"],
  24.     ["Lucy", "B"],
  25.     ["Alice", "B"],
  26.     ["Lisa", "B"],
  27.     ["Karry", "B"]
  28. ])
  29. type = BatchOperator.fromDataframe(nodeType, schemaStr='node string, type string')
  30. metapathBatchOp = HugeMetaPath2VecTrainBatchOp() \
  31.   .setSourceCol("start")            \
  32.   .setTargetCol("end")              \
  33.   .setWeightCol("value")            \
  34.   .setVertexCol("node")             \
  35.   .setTypeCol("type")               \
  36.   .setMetaPath("ABA")               \
  37.   .setWalkNum(2)                    \
  38.   .setWalkLength(2)                 \
  39.   .setMinCount(1)                   \
  40.   .setVectorSize(4)
  41. metapathBatchOp.linkFrom(source, type).print()

Java 代码

  1. import org.apache.flink.types.Row;
  3. import com.alibaba.alink.operator.batch.BatchOperator;
  4. import com.alibaba.alink.operator.batch.huge.HugeMetaPath2VecTrainBatchOp;
  5. import com.alibaba.alink.operator.batch.source.MemSourceBatchOp;
  6. import org.junit.Test;
  8. import java.util.Arrays;
  9. import java.util.List;
  11. public class HugeMetaPath2VecTrainBatchOpTest {
  12.     @Test
  13.     public void testHugeMetaPath2VecTrainBatchOp() throws Exception {
  14.         List <Row> df_data = Arrays.asList(
  15.             Row.of("Bob", "Lucy", 1.),
  16.             Row.of("Lucy", "Bob", 1.),
  17.             Row.of("Lucy", "Bella", 1.),
  18.             Row.of("Bella", "Lucy", 1.),
  19.             Row.of("Alice", "Lisa", 1.),
  20.             Row.of("Lisa", "Alice", 1.),
  21.             Row.of("Lisa", "Karry", 1.),
  22.             Row.of("Karry", "Lisa", 1.),
  23.             Row.of("Karry", "Bella", 1.),
  24.             Row.of("Bella", "Karry", 1.)
  25.         );
  26.         BatchOperator <?> source = new MemSourceBatchOp(df_data, "start string, end string, value double");
  27.         List <Row> nodeType = Arrays.asList(
  28.             Row.of("Bob", "A"),
  29.             Row.of("Bella", "A"),
  30.             Row.of("Karry", "A"),
  31.             Row.of("Lucy", "B"),
  32.             Row.of("Alice", "B"),
  33.             Row.of("Lisa", "B"),
  34.             Row.of("Karry", "B")
  35.         );
  36.         BatchOperator <?> type = new MemSourceBatchOp(nodeType, "node string, type string");
  37.         BatchOperator <?> metapathBatchOp = new HugeMetaPath2VecTrainBatchOp()
  38.             .setSourceCol("start")
  39.             .setTargetCol("end")
  40.             .setWeightCol("value")
  41.             .setVertexCol("node")
  42.             .setTypeCol("type")
  43.             .setMetaPath("ABA")
  44.             .setWalkNum(2)
  45.             .setWalkLength(2)
  46.             .setMinCount(1)
  47.             .setVectorSize(4);
  48.         metapathBatchOp.linkFrom(source, type).print();
  49.     }
  50. }

运行结果

| node | vec | | —- | —- |

| Karry | -0.028718041256070137,0.02825581468641758,0.12125638127326965,0.1207452341914177 |

| Bella | 0.03437831997871399,-0.0477546751499176,0.012570690363645554,-0.0958133116364479 |

| Bob | 0.024427175521850586,0.07044785469770432,-0.04175269603729248,-0.06182029843330383 |

| Lucy | 0.05776885524392128,0.08288335055112839,-0.06490718573331833,0.026563744992017746 |