DataVec/转换-1

数据转换

     数据向量的关键工具之一是转换。数据向量帮助用户将数据集从一个概要映射到另一个概要，并提供一个操作列表来转换类型，格式化数据，把一个2D数据集转换成系列数据。

 

构建一个转换过程

     一个转换过程需要一个概要来成功地转换数据。概要和转换过程类都附带一个帮助构建器类，对于组织代码和避免复杂的构建器来说是很有用的。当两者结合起来它们看起来像如下的样例代码。请注意inputDataSchema是如何传到Builder构造器的。没有它，你的转换过程将会编译失败。

import org.datavec.api.transform.TransformProcess;

TransformProcess tp = new TransformProcess.Builder(inputDataSchema)
    .removeColumns("CustomerID","MerchantID")
    .filter(new ConditionFilter(new CategoricalColumnCondition("MerchantCountryCode", ConditionOp.NotInSet, new HashSet<>(Arrays.asList("USA","CAN")))))
    .conditionalReplaceValueTransform(
        "TransactionAmountUSD",     //被操作的列
        new DoubleWritable(0.0),    //如果条件满足，用新的值
        new DoubleColumnCondition("TransactionAmountUSD",ConditionOp.LessThan, 0.0)) //条件: amount < 0.0
    .stringToTimeTransform("DateTimeString","YYYY-MM-DD HH:mm:ss.SSS", DateTimeZone.UTC)
    .renameColumn("DateTimeString", "DateTime")
    .transform(new DeriveColumnsFromTimeTransform.Builder("DateTime").addIntegerDerivedColumn("HourOfDay", DateTimeFieldType.hourOfDay()).build())
    .removeColumns("DateTime")
    .build();

执行一个转换

 

现在有不同的执行器后台可以使用。使用上面的转换过程对象tp，这里是你如何用一个数据向量在本地执行它。

import org.datavec.local.transforms.LocalTransformExecutor;

List<List<Writable>> processedData = LocalTransformExecutor.execute(originalData, tp);

调式

在概要发生变化的时候在一个转换过程中的每个操作代表一个步骤。有时候，转换的结果不是预期想要的。你可以按如下通过打印转换过程对象tp中每个步骤调试这它。

//Now, print the schema after each time step:
int numActions = tp.getActionList().size();

for(int i=0; i<numActions; i++ ){
    System.out.println("\n\n==================================================");
    System.out.println("-- Schema after step " + i + " (" + tp.getActionList().get(i) + ") --");

    System.out.println(tp.getSchemaAfterStep(i));
}

可用转换和变换

---

TransformProcess

[源码]

 

TransformProcess 定义了一个有序的转换列表，用于在一些数据上执行。

 

getFinalSchema

public Schema getFinalSchema() 

得到这个转换过程将要执行的动作列表

• return

getSchemaAfterStep

public Schema getSchemaAfterStep(int step) 

      行执所有步骤直至并包括指定步骤后返回概要。步骤索引从0开始：所以getSchemaAfterStep(0) 是在一个转换被执行之后。

• 参数step是步骤的索引
• 返回在此（以及所有先前）步骤已被执行之后的数据概要

toJson

public String toJson() 

     为单个示例执行完整的转换序列。如果一个示例被过滤，可能返回空。需要注意的是：一些转换过程操作不能在示例中独立完成。最值得注意的，转换为系列和从系列转换操作要求一次处理全部的数据集合。

• param input 参数 input
• return

toYaml

public String toYaml() 

 把转换过程转化为YAML字符

• 返回一个YAML格式的转换过程

fromJson

public static TransformProcess fromJson(String json) 

反系列化一个JSON字符（由oJson()创建）

• 返回一个从JSON转换而来的转换对象

fromYaml

public static TransformProcess fromYaml(String yaml) 

反系列化一个yaml字符（由toYaml()创建）。 

• 返回一个从YAML转换而来的转换对象。

transform  （注意此方法说明与方法名不一致，官网文档也是错的）

public Builder transform(Transform transform) 

     推断特定列的给定记录读取器的类别。注意，每个“列索引”是上下文(List record = ...; record.get(columnIndex);)中的列。

请注意，作为列传递的任何内容将自动转换为字符串以用于分类目的。期待的输入是字符或是数字（有明显的 toString()表示）需要注意的是返回的类别将按字母顺序排序 

• 参数recordReader是指用于迭代的记录阅读器
• 参数columnIndex是用于获取的类别的索引
• return

filter

public Builder filter(Filter filter) 

在前面的added操作被执行之后添加一个过滤器操作。

• 参数filter是要执行的过滤器操作

filter

public Builder filter(Condition condition) 

基于一个指定的条件，添加一个过滤器操作。如果条件满足（返回true）:移除示例或系列。如果条件不满足（返回false）:保持示例或系列 。

• 参数condition是过滤器需要的条件

removeColumns

public Builder removeColumns(String... columnNames) 

按名称删除所有列

• 参数columnNames是需要删除的列名称的

removeColumns

public Builder removeColumns(Collection<String> columnNames) 

按名称删除所有列

• 参数columnNames是需要删除的列名称的

removeAllColumnsExceptFor

public Builder removeAllColumnsExceptFor(String... columnNames) 

删除除了指定列名称外的所有列

• 参数columnNames是需要保留的列

removeAllColumnsExceptFor

public Builder removeAllColumnsExceptFor(Collection<String> columnNames) 

删除除了指定列名称外的所有列

• 参数columnNames是需要保留的列

renameColumn

public Builder renameColumn(String oldName, String newName) 

重命名一个列

• 参数oldName是旧的列名
• 参数newName是新的列名

renameColumns

public Builder renameColumns(List<String> oldNames, List<String> newNames) 

重命名多列

• 参数oldNames是旧列名列表
• 参数newNames是新列名列表

reorderColumns

public Builder reorderColumns(String... newOrder) 

使用部份列或全部列进行重新排序。如果列名的一部份被指定用作新的顺序，其余的列将按原来的顺序放到最后面。

• 参数newOrder是列的名称，为了可以在输出中展现。

duplicateColumn

public Builder duplicateColumn(String column, String newName) 

 复制一个列

• 参数column是需要被复制的列名
• 参数newName是新列的列名

duplicateColumns

public Builder duplicateColumns(List<String> columnNames, List<String> newNames) 

复制一个集合的列

• 参数columnNames是需要被复制的列名
• 参数newNames是被复制的新列名

integerMathOp

public Builder integerMathOp(String column, MathOp mathOp, int scalar) 

用一个标量在指定的整型数据列上进行数学运算（加法，减法，标量最大值）

• 参数column是需要进行运算的整数列
• 参数mathOp是要进行的数学运算
• 参数scalar是需要用于数学运算的标量

integerColumnsMathOp

public Builder integerColumnsMathOp(String newColumnName, MathOp mathOp, String... columnNames) 

计算并添加一个新的整型列，通过在已存的在列的数字进行数学运算。新列被添加到最后。

• 参数newColumnName是新列的名称
• 参数mathOp是需要在列上执行的数学运算
• 参数columnNames是用于数学运算的列名称

longMathOp

public Builder longMathOp(String columnName, MathOp mathOp, long scalar) 

用一个标量在指定的长整型数据列上进行数学运算（加法，减法，标量最大值）

• 参数columnName是进行数学运算的长整型数据列
• 参数mathOp是要进行的数学运算
• 参数scalar是用来参与数学运算的标量

longColumnsMathOp

public Builder longColumnsMathOp(String newColumnName, MathOp mathOp, String... columnNames) 

计算并添加一个新的长整型列，通过在已存的在列的数字进行数学运算。新列被添加到最后。

• 参数newColumnName是新列的名称
• 参数mathOp是需要在列上执行的数学运算
• 参数columnNames是用于数学运算的列名称

floatMathOp

public Builder floatMathOp(String columnName, MathOp mathOp, float scalar)  

用一个标量在指定的浮点型数据列上进行数学运算（加法，减法，标量最大值）

• 参数columnName是进行数学运算的浮点型数据列
• 参数mathOp是要进行的数学运算
• 参数scalar是用来参与数学运算的标量

floatColumnsMathOp

public Builder floatColumnsMathOp(String newColumnName, MathOp mathOp, String... columnNames) 

计算并添加一个新的浮点型列，通过在已存的在列的数字进行数学运算。新列被添加到最后。

• 参数newColumnName是新列的名称
• 参数mathOp是需要在列上执行的数学运算
• 参数columnNames是用于数学运算的列名称

floatMathFunction

public Builder floatMathFunction(String columnName, MathFunction mathFunction) 

在一个列上进行一个数学运算（例如sin(x), ceil(x), exp(x) 等）

• 参数columnName是需要进行运算的列
• 参数mathFunction是应用于列上的数学函数。

doubleMathOp

public Builder doubleMathOp(String columnName, MathOp mathOp, double scalar) 

用一个标量在指定的双精度型数据列上进行数学运算（加法，减法，标量最大值）

• 参数columnName是进行数学运算的双精度型数据列
• 参数mathOp是要进行的数学运算
• 参数scalar是用来参与数学运算的标量

doubleColumnsMathOp

public Builder doubleColumnsMathOp(String newColumnName, MathOp mathOp, String... columnNames) 

计算并添加一个新的双精度型列，通过在已存的在列的数字进行数学运算。新列被添加到最后。

• 参数newColumnName是新列的名称
• 参数mathOp是需要在列上执行的数学运算
• 参数columnNames是用于数学运算的列名称

doubleMathFunction

public Builder doubleMathFunction(String columnName, MathFunction mathFunction)  

在一个列上进行一个数学运算（例如sin(x), ceil(x), exp(x) 等）

• 参数columnName是需要进行运算的列
• 参数mathFunction是应用于列上的数学函

timeMathOp

public Builder timeMathOp(String columnName, MathOp mathOp, long timeQuantity, TimeUnit timeUnit) 

在一个指定的列上进行一个数学运算（加法，减法，标量最大值）

• 参数columnName是要进行运算的整型数据列名称
• 参数mathOp是指数学运算
• 参数timeQuantity是用于数学运算的数量
• 参数是用于数学运算的数量的单位

categoricalToOneHot

public Builder categoricalToOneHot(String... columnNames) 

  转换指定的列，从分类形式转换为one-hot形式 。这涉及到创建多个新的列。

•  参数columnNames是用于转换为one-hot形式的分类列的名称

categoricalToInteger

public Builder categoricalToInteger(String... columnNames) 

  转换指定的列，从分类形式转换为整型形式 。这将用整型形式替换指定的分类列，整型的范转是从0 到 分类数量-1

• 参数columnNames是要转换为整型形式的列名称

integerToCategorical

public Builder integerToCategorical(String columnName, List<String> categoryStateNames) 

 给定指定的状态名称，将整型（假设值为0到分类数量-1）表示的列转换为用分类表示的列

• 参数columnName是需要转换的列名
• 参数categoryStateNames是分类列的状态名称

integerToCategorical

public Builder integerToCategorical(String columnName, Map<Integer, String> categoryIndexNameMap) 

给定指定的索引与状态名称的映射，将整型（假设值为0到分类数量-1）表示的列转换为用分类表示的列

• 参数columnName是需要转换的列名
• 参数categoryIndexNameMap是分类列的索引与状态名称的映射

integerToOneHot

public Builder integerToOneHot(String columnName, int minValue, int maxValue) 

把一个整型列转换为one-hot列，基于整型列的值

• 参数columnName是整型列的名称
• 参数minValue是整型列可能的最小值（包括minValue）
• 参数maxValue是整型列可能的最大值（包括maxValue）

addConstantColumn

public Builder addConstantColumn(String newColumnName, ColumnType newColumnType, Writable fixedValue) 

添加一个新列，其中列中的所有值都是相同的和被指定的。

• 参数newColumnName是指新列的名称
• 参数newColumnType是指新列的数据类型
• 参数fixedValue是一个新列中所有记录的值

addConstantDoubleColumn

public Builder addConstantDoubleColumn(String newColumnName, double value) 

添加一个新的双精度类型列，这个列的所有记录的值都相同。

• 参数newColumnName是新列的名称
• 参数value是新列中所有记录的值

addConstantIntegerColumn

public Builder addConstantIntegerColumn(String newColumnName, int value)  

添加一个新的整型列，这个列的所有记录的值都相同。

• 参数newColumnName是新列的名称
• 参数value是新列中所有记录的值

addConstantLongColumn

public Builder addConstantLongColumn(String newColumnName, long value)  

添加一个新的长整型列，这个列的所有记录的值都相同。

• 参数newColumnName是新列的名称
• 参数value是新列中所有记录的值

convertToString

public Builder convertToString(String inputColumn) 

把指定的列转换为字符

• 参数inputColumn 是要转换的列
• 返回构建器模式

convertToDouble

public Builder convertToDouble(String inputColumn) 

把指定的列转换为双精度

• 参数inputColumn 是要转换的列
• 返回构建器模式

convertToInteger

public Builder convertToInteger(String inputColumn)  

把指定的列转换为整型

• 参数inputColumn 是要转换的列
• 返回构建器模式

normalize

public Builder normalize(String column, Normalize type, DataAnalysis da) 

用给定的归一化类型归一化指定的列

• 参数column是指需要归一化的列
• 参数type是要应用的归一化的类型
• 参数da是指数据分析类对象

convertToSequence

public Builder convertToSequence(String keyColumn, SequenceComparator comparator) 

按照一些键，将独立的记录/实例集合转换成序列。在每个序列中，值是按给定的序列比较器排序的。

• 参数keyColumn是作为键使用的列（具有相同键的值将被合并成序列）
• 参数comparator是一个在每个序列中用于排序的比较器（例如，按时间或按字符顺序）

convertToSequence

public Builder convertToSequence() 

将独立的记录/实例集合转换成序列，每个例子简单的当作一个长度为1的序列，没有任何连接/分组操作。需要注意的是通常需要加入连接/分组；使用convertToSequence(List, SequenceComparator)来实现此功能。

 

 

convertToSequence

public Builder convertToSequence(List<String> keyColumns, SequenceComparator comparator) 

将独立的记录/实例集合转换成序列，每个序列是按一个或多个键值分组的（值在一个或多个列中），在每个序列中，值是用所提供的序列比较器进行排序。

• 参数keyColumn是作为键使用的列（具有相同键的值将被合并成系列）
• 参数comparator是一个在每个序列中用于排序的比较器（例如，按时间或按字符顺序）

convertFromSequence

public Builder convertFromSequence() 

将一个序列转换为独立的值的集合（通过把每个序列中的每个值当作一个单独实例）

 

splitSequence

public Builder splitSequence(SequenceSplit split) 

将系列分割为1个或多个序列。用于例如将一个大的序列分割为小的序列集合。

 

• 参数SequenceSplit是指如何进行分割

trimSequence

public Builder trimSequence(int numStepsToTrim, boolean trimFromStart) 

序列修剪变换在序列中移除第一个或倒数第N个值。需要注意的是如果输入序列的长度小于或等于N，结果序列的长度可能为0。

 

• 参数numStepsToTrim是修剪序列步骤的次数
• 参数trimFromStart如果为true,则从序列的开始修整值。如果为false，从序列的结尾开始。

 

offsetSequence （此方法说明并不清楚）

public Builder offsetSequence(List<String> columnsToOffset, int offsetAmount,
                                      SequenceOffsetTransform.OperationType operationType) 

在指定列上执行序列操作。需要注意的是默认情况下，这也会截断指定偏移量的序列。使用{- 代码 transform(new SequenceOffsetTransform(…)} 来改变这种情况. 查看 {- link SequenceOffsetTransform} 来知道它是要进行的操作和如何操作的。

 

 

• 参数columnsToOffset是要偏移的列 
• 参数offsetAmount是指定的列的偏移量。（正偏移：'columnsToOffset'是移动到以后的时间步长）
• 参数operationType是指是否在原来的地方进行偏移操作或是通过添加一个新的列。

reduce

public Builder reduce(IAssociativeReducer reducer) 

缩减（聚合/合并）一个实例集合（通常按键来进行）。需要注意的是减少只能在标准的（非序列）数据上进行操作。

 

• 参数reducer是要使用的缩减器 

reduceSequence

public Builder reduceSequence(IAssociativeReducer reducer) 

为每个独立序列进行缩减（聚合/合并）一个序列实例集合。需要注意的是这个方法倒致非序列的数据。相反，如果你喜欢缩减后的长度为1的序列，可以使用transform(new ReduceSequenceTransform(reducer))方法。

• 参数reducer是用于在每个窗口的缩减器。

reduceSequenceByWindow

public Builder reduceSequenceByWindow(IAssociativeReducer reducer, WindowFunction windowFunction) 

使用一个窗口函数为每个独立序列进行缩减（聚合/合并）一个序列实例集合。例如，在24小时内取所有的记录／实例，（使用缩减器）把它们转换为单个值。这个例子中，时间周期是24小时，输出是一个序列。

• 参数reducer是在每个窗中使用的缩减器。
• 参数windowFunction是分别在每个独立序列上找到应用的窗口函数。

sequenceMovingWindowReduce

public Builder sequenceMovingWindowReduce(String columnName, int lookback, ReduceOp op) 

 

序列移动窗口缩减变换：添加一个新列，它的值是：

(a)使用单个列中最后n个值的窗口

(b)在窗口上应用一个缩减操作来计算一个新值，例如，这个转换器可以用于实现一个最后n个值的一个简单移动平均，或确定最后N个时间步长中的最小值或最大值。

例如， 对于一个长度为20的简单移动平均：使用new SequenceMovingWindowReduceTransform(“myCol”, 20, ReduceOp.Mean)

 

 

• 参数columnName是进行窗口操作的列 
• 参数lookback是回顾窗口期
• 参数op是每个窗口进行的缩减操作

calculateSortedRank

public Builder calculateSortedRank(String newColumnName, String sortOnColumn, WritableComparator comparator) 

 

计算排序的秩：在排序后计算每个实例的秩。例始，我们可能有一些数字“分数”列，根据那个列，我们想要知道每个实例的秩（排列顺序）。

每个实例的秩将被添加到一个新的长整型列。从0开始索引 ；实例会有0到数据集大小减1的索引。目前计算排序的秩只能应用在标准的数据上，除此外，当前的实现只能在一列上排序。

 

• 参数newColumnName是找新列的名称（将包括每个实例的秩）
• 参数sortOnColumn是需要排序的列
• 参数comparator是用于实例的比较器

calculateSortedRank

public Builder calculateSortedRank(String newColumnName, String sortOnColumn, WritableComparator comparator,
                                           boolean ascending) 

计算排序的秩：在排序后计算每个实例的秩。例始，我们可能有一些数字“分数”列，根据那个列，我们想要知道每个实例的秩（排列顺序）。

每个实例的秩将被添加到一个新的长整型列。从0开始索引 ；实例会有0到数据集大小减1的索引。目前计算排序的秩只能应用在标准的数据上，除此外，当前的实现只能在一列上排序。

 

• 参数newColumnName是找新列的名称（将包括每个实例的秩）
• 参数sortOnColumn是需要排序的列
• 参数comparator是用于实例的比较器
• 参数ascending如果为true: 升序排序. False: 降序排序

stringToCategorical

public Builder stringToCategorical(String columnName, List<String> stateNames) 

将指定的列转换为分类列。必须提供状态名称。

• 参数columnName是要被转换为分类列的列名
• 参数stateNames是分类的状态名

stringRemoveWhitespaceTransform

public Builder stringRemoveWhitespaceTransform(String columnName) 

在指定的字符列的值中移除空白字符

• 参数columnName是需要移除空白字符的列名