Press "Enter" to skip to content

Alink漫谈(十八) :源码解析 之 多列字符串编码MultiStringIndexer

本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.

Alink漫谈(十八) :源码解析 之 多列字符串编码MultiStringIndexer

 

目录

Alink漫谈(十八) :源码解析 之 多列字符串编码MultiStringIndexer

0x00 摘要

 

Alink 是阿里巴巴基于实时计算引擎 Flink 研发的新一代机器学习算法平台,是业界首个同时支持批式算法、流式算法的机器学习平台。本文将带领大家来分析Alink中 MultiStringIndexer 的实现。

 

因为Alink的公开资料太少,所以以下均为自行揣测,肯定会有疏漏错误,希望大家指出,我会随时更新。

 

本文缘由是想分析GBDT,发现GBDT涉及到MultiStringIndexer的使用,所以只能先分析MultiStringIndexer 。

 

0x01 概念

 

Alink的官方介绍是:MultiStringIndexer训练组件的作用是训练一个模型用于将多列字符串映射为整数。

 

具体来说,StringIndexer(字符串-索引变换)将标签的”字符串列”编码为”标签索引的列”。

标签索引序列的取值范围是[0,numLabels(字符串中所有出现的单词去掉重复的词后的总和)],按照标签出现频率排序,出现最多的标签索引为0(具体为升序降序是可以配置的)。
如果输入是数值型,我们先将数值映射到字符串,再对字符串进行索引化。
如果下游的pipeline(例如:Estimator或者Transformer)需要用到索引化后的标签序列,则需要将这个pipeline的输入列名字指定为索引化序列的名字。大部分情况下,通过setSelectedCols设置输入的列名。

以这些输入为例:

 

("football", "can"),
("football", "hhh"),
("football", "zzz"),
("basketball", "zzz"),
("basketball", "can"),
("tennis", "can")

 

对于第一列,MultiStringIndexer 对数据集的label进行重新编号。按label出现的频次,转换成0 ~ numOfLabels – 1(分类个数)。如果是按照从高到低排序,则频次最高的转换为0,以此类推,比如:

football,出现次数最多,出现了3次,转换(编号)为0
其次是basketball,出现了2次,编号为1,以此类推。

在应用StringIndexer对labels进行重新编号后,带着这些编号后的label对数据进行了训练,并接着对其他数据进行了预测,得到预测结果,预测结果的label也是重新编号过的,因此需要转换回来。

 

0x02 示例代码

 

示例代码如下,本示例代码中,是按照升序排列,即football总数为3,则其idx为3,tennis个数为1,其idx为0:

 

public class MultiStringIndexerExample {
    static AlgoOperator getData(boolean isBatch) {
        Row[] array = new Row[] {
                Row.of("football", "can"),
                Row.of("football", "hhh"),
                Row.of("football", "zzz"),
                Row.of("basketball", "zzz"),
                Row.of("basketball", "can"),
                Row.of("tennis", "can")
        };
        if (isBatch) {
            return new MemSourceBatchOp(
                    Arrays.asList(array), new String[] {"a", "b"});
        } else {
            return new MemSourceStreamOp(
                    Arrays.asList(array), new String[] {"a", "b"});
        }
    }
    public static void main(String[] args) throws Exception {
        BatchOperator data = (BatchOperator)getData(true);
        MultiStringIndexer stringindexer = new MultiStringIndexer()
                .setSelectedCols("a", "b")
                .setOutputCols("a_indexed", "b_indexed")
                .setStringOrderType("frequency_asc");
        stringindexer.fit(data).transform(data).print();
    }
}

 

输出如下:

 

a|b|a_indexed|b_indexed
-|-|---------|---------
football|can|2|2
football|hhh|2|0
football|zzz|2|1
basketball|zzz|1|1
basketball|can|1|2
tennis|can|0|2

 

转换成表格看的更清楚。

a b a_indexed b_indexed
football can 2 2
football hhh 2 0
football zzz 2 1
basketball zzz 1 1
basketball can 1 2
tennis can 0 2

 

0x03 总体逻辑

 

我们先给出一个流程图

 

 

老套路,我们从 MultiStringIndexerTrainBatchOp.linkFrom开始挖掘。

 

@Override
public MultiStringIndexerTrainBatchOp linkFrom(BatchOperator<?>... inputs) {
    BatchOperator<?> in = checkAndGetFirst(inputs);
    // 示例中有 .setSelectedCols("a", "b"),这里是取出具体列名字
    final String[] selectedColNames = getSelectedCols();
    // 获取列的类型
    final String[] selectedColSqlType = new String[selectedColNames.length];
    for (int i = 0; i < selectedColNames.length; i++) {
        selectedColSqlType[i] = FlinkTypeConverter.getTypeString(
            TableUtil.findColTypeWithAssertAndHint(in.getSchema(), selectedColNames[i]));
    }
// runtime打印数据
selectedColNames = {String[2]@2536} 
 0 = "a"
 1 = "b"
selectedColSqlType = {String[2]@2537} 
 0 = "VARCHAR"
 1 = "VARCHAR"
    // 获取选取列对应的数据
    DataSet<Row> inputRows = in.select(selectedColNames).getDataSet();
    // 
    DataSet<Tuple3<Integer, String, Long>> indexedToken =
        StringIndexerUtil.indexTokens(inputRows, getStringOrderType(), 0L, true);
    DataSet<Row> values = indexedToken
        .mapPartition(new RichMapPartitionFunction<Tuple3<Integer, String, Long>, Row>() {
            @Override
            public void mapPartition(Iterable<Tuple3<Integer, String, Long>> values, Collector<Row> out)
                throws Exception {
                Params meta = null;
                if (getRuntimeContext().getIndexOfThisSubtask() == 0) {           
                    // 第一个task会做这个计算,就是把列名,列类型作为元数据传送
                    meta = new Params().set(HasSelectedCols.SELECTED_COLS, selectedColNames)
                        .set(HasSelectedColTypes.SELECTED_COL_TYPES, selectedColSqlType);
                }
 
// runtime打印数据              
meta = {[email protected]} "Params {selectedCols=["a","b"], selectedColTypes=["VARCHAR","VARCHAR"]}"
 params = {[email protected]}  size = 2              
              
                new MultiStringIndexerModelDataConverter().save(Tuple2.of(meta, values), out);
            }
        })
        .name("build_model");
    this.setOutput(values, new MultiStringIndexerModelDataConverter().getModelSchema());
    return this;
}

 

训练过程总体逻辑总结如下:

取出具体列名字,列的类型;
获取”选取列”对应的数据;
把列名,列类型作为元数据传送;
StringIndexerUtil.indexTokens 给各个列的不同字串赋予连续的indices。每列的 indices 彼此不相关;

调用到 indexSortedByFreq(data, startIndex, ignoreNull, true) ,作用是给各个列的不同字串赋予连续的indices,indices是按照字符串出现的频率排序;

调用到 countTokens的作用是按照 “列idx”,”word” 来合并计算单词个数,得到<“列idx”,”word”,单词个数>,比如第一列中,football这个单词的个数是3,则返回三元组是 <0,football,3>,其中列的idx从0开始计算。

调用 flattenTokens 把输入数据 Row 给打散,返回 A DataSet of tuples of column index and token,即<“列idx”,”word”>。比如对于 Row.of(“football”, “can”) 这个输入,flattenTokens 输出两个Tuple2 ,<0, “football”> 和 <1, “can”>。
对上面结构进行map操作,输出<column idx, word, 1L>,比如 <0, “football”, 1L> ;
按照 “列idx”,”word” 来分组;
按照 “列idx”,”word” 来合并计算单词个数;

indexSortedByFreq会对countTokens返回的结果<“列idx”,”word”,词频>处理;

首先按照 列idx 做分组;
然后在上面结果基础上,按照单词个数排序;
排序的index是以输入参数startIndex开始,startIndex在这里是0;
最后得到 第一列的 (0,football,0),(0,basketball,1),(0,football,2);第二列的数据 (1,hhh,0),(1,zzz,1),(1,can,2);

把indexTokens的结果存储为模型,其中使用之前提到的 “把列名,列类型作为元数据”。

下面具体剖析后两个阶段。

 

0x04 Add Index to Token

 

这部分就是给各个列的不同字串赋予连续的indices。每列的 indices 彼此不相关。

 

具体是由StringIndexerUtil.indexTokens 做到的。

 

public static DataSet<Tuple3<Integer, String, Long>> indexTokens(
    DataSet<Row> data, HasStringOrderTypeDefaultAsRandom.StringOrderType orderType,
    final long startIndex, final boolean ignoreNull) {
    		case FREQUENCY_ASC:
                return indexSortedByFreq(data, startIndex, ignoreNull, true);
}

 

4.1 合并计算单词个数

 

indexSortedByFreq会调用countTokens来计算单词个数,所以我们先看countTokens。

 

countTokens的作用是按照 “列idx”,”word” 来合并计算单词个数,比如第一列中,football这个单词的个数是3,则返回三元组是 <0,football,3>,其中列的idx从0开始计算。

 

具体逻辑如下:

调用 flattenTokens 把输入数据 Row 给打散,返回 A DataSet of tuples of column index and token,即<“列idx”,”word”>。比如对于 Row.of(“football”, “can”) 这个输入,flattenTokens 输出两个Tuple2 ,<0, “football”> 和 <1, “can”>。
对上面结果进行map操作,输出<column idx, word, 1L>,比如 <0, “football”, 1L> ,这个是计数的常规操作。
按照 “列idx”,”word” 来分组;
按照 “列idx”,”word” 来合并计算单词个数,就是不停归并上面的 1L。

4.1.1 打散输入数据

 

其中 flattenTokens 的作用是把输入数据 Row 给打散,返回 A DataSet of tuples of column index and token.。

 

比如对于 Row.of(“football”, “can”) 这个输入,flattenTokens 使用 out.collect(Tuple2.of(i, String.valueOf(o))); 输出两个Tuple2。

 

value = {[email protected]} "football,can"
 fields = {Object[2]@9215} 
  0 = "football"
  1 = "can"
输出 <0, "football"> 和 <1, "can">

 

4.1.2 分组计算个数

 

这是通过flattenTokens的结果进行 map,groupBy,reduce的一系列操作完成的。

 

具体代码如下:

 

public static DataSet<Tuple3<Integer, String, Long>> countTokens(DataSet<Row> data, final boolean ignoreNull) {
    return flattenTokens(data, ignoreNull) // 把输入数据 Row 给打散
        .map(new MapFunction<Tuple2<Integer, String>, Tuple3<Integer, String, Long>>() {
            @Override
            public Tuple3<Integer, String, Long> map(Tuple2<Integer, String> value) throws Exception {
                return Tuple3.of(value.f0, value.f1, 1L); // 输出<column idx, word, 1L>,比如 <0, "football", 1L> 
            }
        })
        .groupBy(0, 1) // 按照 "列idx","word" 来分组
        .reduce(new ReduceFunction<Tuple3<Integer, String, Long>>() {
            @Override
            public Tuple3<Integer, String, Long> reduce(Tuple3<Integer, String, Long> value1, Tuple3<Integer, String, Long> value2) throws Exception {
                value1.f2 += value2.f2;
                return value1; // 按照 "列idx","word" 来合并计算单词个数
            }
        })
        .name("count_tokens");
}
// reduce之后发出
value1 = {[email protected]} "(0,football,3)"
 f0 = {[email protected]} 0
 f1 = "football"
 f2 = {[email protected]} 3

 

4.2 合并计算单词个数

 

前面 countTokens的 返回三元组是 <列idx”,”word” ,词频>,其中列的idx从0开始计算。

 

indexSortedByFreq会对countTokens返回的结果<“列idx”,”word”,词频>处理;

首先按照 列idx 做分组;
然后在上面结果基础上,按照单词个数排序;
排序的index是以输入参数startIndex开始,startIndex在这里是0;
最后得到 第一列的 (0,tennis,0),(0,basketball,1),(0,football,2);第二列的数据 (1,hhh,0),(1,zzz,1),(1,can,2);

具体代码如下:

 

public static DataSet<Tuple3<Integer, String, Long>> indexSortedByFreq(
    DataSet<Row> data, final long startIndex, final boolean ignoreNull, final boolean isAscending) {
    return countTokens(data, ignoreNull)
        .groupBy(0) //按照 列idx 做分组
        .sortGroup(2, isAscending ? Order.ASCENDING : Order.DESCENDING) //按照单词个数排序
        .reduceGroup(new GroupReduceFunction<Tuple3<Integer, String, Long>, Tuple3<Integer, String, Long>>() {
            @Override
            public void reduce(Iterable<Tuple3<Integer, String, Long>> values,
                               Collector<Tuple3<Integer, String, Long>> out) {
                long id = startIndex;
                for (Tuple3<Integer, String, Long> value : values) {
                    out.collect(Tuple3.of(value.f0, value.f1, id++)); // 归并
                }
            }
        });
}

 

0x05 输出模型

 

这部分分为两部分:

输出元数据,就是之前得到的 “把列名,列类型作为元数据”。
输出具体每一列的每一个单词信息,比如 第一列的 (0,tennis,0),(0,basketball,1),(0,football,2);第二列的数据 (1,hhh,0),(1,zzz,1),(1,can,2);

public class MultiStringIndexerModelDataConverter implements
    ModelDataConverter<Tuple2<Params, Iterable<Tuple3<Integer, String, Long>>>, MultiStringIndexerModelData> {
    @Override
    public void save(Tuple2<Params, Iterable<Tuple3<Integer, String, Long>>> modelData, Collector<Row> collector) {
        if (modelData.f0 != null) {
            collector.collect(Row.of(-1L, modelData.f0.toJson(), null));
        }
        modelData.f1.forEach(tuple -> {
            collector.collect(Row.of(tuple.f0.longValue(), tuple.f1, tuple.f2));
        });
    }  
}
tuple = {[email protected]} "(0,tennis,0)"
 f0 = {[email protected]} 0
 f1 = "tennis"
 f2 = {[email protected]} 0

 

0x06 预测

 

预测功能是在 ModelMapperAdapter 完成的。

 

public class ModelMapperAdapter extends RichMapFunction<Row, Row> implements Serializable {
    private final ModelMapper mapper;
    private final ModelSource modelSource;
    @Override
    public void open(Configuration parameters) throws Exception {
        List<Row> modelRows = this.modelSource.getModelRows(getRuntimeContext());
        this.mapper.loadModel(modelRows); //加载模型
    }
    @Override
    public Row map(Row row) throws Exception {
        return this.mapper.map(row); //预测
    }
}

 

6.1 加载模型

 

MultiStringIndexerModelDataConverter中我们会进行模型加载。

首先会加载元信息
其次会逐条加载模型信息

public MultiStringIndexerModelData load(List<Row> rows) {
    MultiStringIndexerModelData modelData = new MultiStringIndexerModelData();
    modelData.tokenAndIndex = new ArrayList<>();
    modelData.tokenNumber = new HashMap<>();
    for (Row row : rows) {
        long colIndex = (Long) row.getField(0);
        if (colIndex < 0L) { // 元数据
            modelData.meta = Params.fromJson((String) row.getField(1));
        } else { // 具体模型信息
            int columnIndex = ((Long) row.getField(0)).intValue();
            Long tokenIndex = Long.valueOf(String.valueOf(row.getField(2)));
            modelData.tokenAndIndex.add(Tuple3.of(columnIndex, (String) row.getField(1), tokenIndex));
            modelData.tokenNumber.merge(columnIndex, 1L, Long::sum); // 合并列数据个数
        }
    }
    // To ensure that every columns has token number.
    int numFields = 0;
    if (modelData.meta != null) {
        numFields = modelData.meta.get(HasSelectedCols.SELECTED_COLS).length;
    }
    for (int i = 0; i < numFields; i++) {
        modelData.tokenNumber.merge(i, 0L, Long::sum);
    }
    return modelData;
}

 

最后模型内容如下,其中 tokenNumber 表示每列的数据有几个,tokenAndIndex表示具体信息,比如(0,tennis,0),(0,basketball,1),(0,football,2) 就表示他们都是第一列的,basketball转换后的数据是 1:

 

modelData = {[email protected]} 
 meta = {[email protected]} "Params {selectedCols=["a","b"], selectedColTypes=["VARCHAR","VARCHAR"]}"
 tokenAndIndex = {[email protected]}  size = 6
  0 = {[email protected]} "(0,football,2)"
  1 = {[email protected]} "(0,tennis,0)"
  2 = {[email protected]} "(1,zzz,1)"
  3 = {[email protected]} "(1,hhh,0)"
  4 = {[email protected]} "(0,basketball,1)"
  5 = {[email protected]} "(1,can,2)"
 tokenNumber = {[email protected]}  size = 2
  {[email protected]} 0 -> {[email protected]} 3
  {[email protected]} 1 -> {[email protected]} 3
numFields = 2

 

6.2 预测

 

预测是在 MultiStringIndexerModelMapper 完成的。

 

// 假设输入是:row = {[email protected]} "football,can"
// 选择的列是:selectedColNames = {String[2]@9314}  0 = "a" 1 = "b"
// 模型映射器是:
this = {[email protected]} 
 indexMapper = {[email protected]}  size = 2
  {[email protected]} 0 -> {[email protected]}  size = 3
   key = {[email protected]} 0
    value = 0
   value = {[email protected]}  size = 3
    "basketball" -> {[email protected]} 1
    "football" -> {[email protected]} 2
    "tennis" -> {[email protected]} 0
  {[email protected]} 1 -> {[email protected]}  size = 3
   key = {[email protected]} 1
    value = 1
   value = {[email protected]}  size = 3
    "can" -> {[email protected]} 2
    "hhh" -> {[email protected]} 0
    "zzz" -> {[email protected]} 1

 

则经历过下列代码,最后就可以进行预测

 

public Row map(Row row) throws Exception {
    Row result = new Row(selectedColNames.length);
    for (int i = 0; i < selectedColNames.length; i++) {
        Map<String, Long> mapper = indexMapper.get(i);
        int colIdxInData = selectedColIndicesInData[i];
        Object val = row.getField(colIdxInData);
        String key = val == null ? null : String.valueOf(val);
        Long index = mapper.get(key);
        if (index != null) {
            result.setField(i, index); // 我们主要执行在这里
        } else {
        }
    }
// 最后预测结果是:
row = {[email protected]} "football,can"
result = {[email protected]} "2,2"
    
    return outputColsHelper.getResultRow(row, result);
}

 

0xFF 参考

 

Spark之特征预处理

Be First to Comment

发表评论

电子邮件地址不会被公开。 必填项已用*标注