Algorithm Star，简称“AS”，中文名为算法之星，由Ling Yu Zhao开发，是针对机器学习过程中的Java库，其具有良好的Java与Scala兼容性，于1.14版本开始重大改动，其中包含样本洗牌随机分布，特征选择，特征提取，度量计算，差异计算，路径推断，分类等计算组件，同时也具有运算符风格的复数，坐标，向量，矩阵等操作数，开发者Ling Yu Zhao于2022年发布的一款开源库，能够将复杂的机器学习简单化。

Algorithm Star采用apache2.0版本开源协议。支持通过maven坐标获取到框架本身，目前在GitHub中进行托管（GitHub - BeardedManZhao/algorithmStar: Toolkits for various algorithms, support vector computing and other functions, machine learning and mathematics, medicine, artificial intelligence and other fields of high practicality. | 用于各种算法、支持向量计算等功能，机器学习和数学、医学、人工智能等领域具有很高的实用性。）。

AS库的一般处理流程

数据采集与清洗

指的是数据的获取操作，在这一步获取到的数据是各种类型的原始数据，往往需要使用到各种大数据技术来采集到我们需要的数据，是整个工程中的第一项任务，在这一项任务中获取到的数据往往是具有噪音的数据，其中包含许多的冗余，因此要进行第二步，针对采集到的数据进行简单清洗。

数据清洗的方式有多种，例如去除空值与不合法的行等，使得其能够被按照预期转换，第一层过滤之后开始进行特征提取，将数据本身转换成为向量或矩阵等。

向量生成与特征提取选择

针对数据样本以及我们的目的和需求，对文本使用合适的特征提取操作，将获取到的数据转换成为AS中的向量/矩阵对象，使得其具有运算功能。

值得注意的是，多行数据的特征提取往往都是提取成为一个矩阵，那么矩阵中如果有一些没有特征的行向量，这将会影响最终的模型误差，因此对于这些行向量应进行特征选择操作，去除掉。

机器学习

作为整个特征工程中的核心操作，是需要频繁与AS库进行交互的一项任务，此任务中，需要涉及到AS库中的各种计算组件，通过这些计算组件达到最终的特征处理需求，目前库中有诸多函数，其中支持8种以上距离算法，3种以上的聚合算法，两种分类算法，5种差异算法等诸多机器学习算法，每一种算法在AS库中都是一个计算组件对象，且可以支持诸多操作组件，例如计算坐标之间的距离，计算矩阵中多个向量之间的类别等。

在计算过程中，AS库将遵循不拷贝原则，能不拷贝出一个新的对象就不拷贝，尽量在不修改原数据的基础上针对结果进行计算，当然，其中作为被计算矩阵与向量对象，允许用户直接获取到正在维护中的只读数组，也允许用户直接将正在维护中的数组拷贝出来一份新数据对象。

后续处理

在经过复杂的机器学习之后，我们应该会得到一种数据模型与数据结果，在这里的结果可以进行校验与后续的数据使用操作等，通过AS库，会使得Java中的机器学习不再困难与痛苦，多个重载函数的配合，使得Java中原生的基本数据类型也可以传递给计算组件进行机器学习的任务。

Algorithm Star使用

数据类型-操作数

操作数是AS库中的被计算对象，例如向量等，这类对象在AS库中能够实现加减乘除等基本运算，在AS库中每一个对象都在维护一个数组，这些数组在向量对象中的表现形式是一个基元的基本数据类型数组，因此在计算的时候具有良好的性能与原生支持。

操作数接口中的常用通用函数

Vector

`限定符和类型`	方法和说明
Object	clone`()`
`protected abstract` ArrayType	copyToNewArray`()`
`abstract` ImplementationType	expand`()`
`abstract int`	getNumberOfDimensions`()`
`abstract` ElementType	innerProduct`(`ImplementationType `vector)` 计算两个向量的内积，也称之为数量积，具体实现请参阅api说明 Calculate the inner product of two vectors, also known as the quantity product, please refer to the api node for the specific implementation
`abstract` ElementType	moduleLength`()` 计算该向量的模长，具体实现请参阅api说明 Calculate the modulo length of the vector, please refer to the api node for the specific implementation
`abstract` ImplementationType	multiply`(`ImplementationType `vector)` 两个向量相乘，同时也是两个向量的外积，具体实现请参阅api说明 The multiplication of two vectors is also the outer product of the two vectors.
`abstract` ImplementationType	shuffle`(long seed)` 将本对象中的所有数据进行洗牌打乱，随机分布数据行的排列。
String	toString`()`

ASVector

限定符和类型	方法和说明
`abstract` ImplementationType	add`(`ImplementationType `value, boolean ModifyCaller)` 在两个向量对象之间进行计算的函数，自从1.13版本开始支持该函数的调用，该函数中的计算并不会产生一个新的向量，而是将计算操作作用于原操作数中 The function that calculates between two vector objects supports the call of this function since version 1.13.
`abstract` ImplementationType	diff`(`ImplementationType `value, boolean ModifyCaller)` 在两个向量对象之间进行计算的函数，自从1.13版本开始支持该函数的调用，该函数中的计算并不会产生一个新的向量，而是将计算操作作用于原操作数中 The function that calculates between two vector objects supports the call of this function since version 1.13.
`abstract` ImplementationType	multiply`(`ImplementationType `value, boolean ModifyCaller)` 在两个向量对象之间进行计算的函数，自从1.13版本开始支持该函数的调用，该函数中的计算并不会产生一个新的向量，而是将计算操作作用于原操作数中 The function that calculates between two vector objects supports the call of this function since version 1.13.
`protected abstract void`	reFresh`()` 刷新操作数对象的所有字段
`abstract` ArrayType	toArray`()` 获取到本向量对象正在维护中的数组对象，注意，这里不会进行拷贝操作。

RangeVector

限定符和类型	方法和说明
`protected abstract` ArrayType	copyToNewArray`()`
`abstract` ImplementationType	expand`()`
`abstract void`	forEach`(`java.util.function.Consumer`<`ElementType`> action)` 区间内元素迭代器 Element iterator in interval
`abstract` ElementType	getRangeEnd`()`
`abstract` ElementType	getRangeStart`()`
`abstract` ElementType	getRangeSum`()`
`abstract double`	moduleLength`()` 计算该向量的模长，具体实现请参阅api说明 Calculate the modulo length of the vector, please refer to the api node for the specific implementation
`abstract` VectorType	shuffle`(long seed)` 将本对象中的所有数据进行洗牌打乱，随机分布数据行的排列。
`int`	size`()`
`abstract` VectorType	toVector`()` 将本区间的向量转换成具体向量。

Matrix

限定符和类型	方法和说明
ImplementationType	add`(`ImplementationType `value, boolean lock)` 在两个向量对象之间进行计算的函数，自从1.13版本开始支持该函数的调用，该函数中的计算并不会产生一个新的向量，而是将计算操作作用于原操作数中 The function that calculates between two vector objects supports the call of this function since version 1.13.
`abstract` ArrayType	copyToNewArray`()`
`abstract` ArraysType	copyToNewArrays`()` 该方法将会获取到矩阵中的二维数组，值得注意的是，在该函数中获取到的数组是一个新的数组，不会有任何的关系。
ImplementationType	diff`(`ImplementationType `value, boolean lock)` 在两个向量对象之间进行计算的函数，自从1.13版本开始支持该函数的调用，该函数中的计算并不会产生一个新的向量，而是将计算操作作用于原操作数中 The function that calculates between two vector objects supports the call of this function since version 1.13.
`abstract` ElementType	get`(int row, int col)` 获取到矩阵中指定坐标点的数值
`int`	getColCount`()`
`int`	getRowCount`()`
ElementType	innerProduct`(`ImplementationType `value, boolean lock)`
`boolean`	isUnlock`()`
ImplementationType	multiply`(`ImplementationType `value, boolean lock)` 在两个向量对象之间进行计算的函数，自从1.13版本开始支持该函数的调用，该函数中的计算并不会产生一个新的向量，而是将计算操作作用于原操作数中 The function that calculates between two vector objects supports the call of this function since version 1.13.
`abstract` ArrayType	toArray`()`
ArraysType	toArrays`()` 该方法将会获取到矩阵中的二维数组，注意，与toArray一样返回的是正在被维护的数组对象，建议作为只读变量使用。
String	toString`()`
`abstract` ImplementationType	transpose`()` 将现有矩阵的转置矩阵获取到 Get the transpose of an existing matrix into

NumberMatrix

限定符和类型

方法和说明

abstract ImplementationType

deleteRelatedDimensions(int index, double thresholdLeft, double thresholdRight)

删除与目标索引维度相关的所有行维度，并返回新矩阵对象。

abstract ImplementationType

featureSelection(double threshold)

去除冗余特征维度，将当前矩阵中的每一个维度都进行方差或无向差计算，并将过于稳定的冗余特征去除。

Coordinate

限定符和类型

方法和说明

ImplementationType

extend()

显式拓展到子类的函数

int

getNumberOfDimensions()

一般是获取到坐标对象中的维度

IntegerCoordinates

限定符和类型	方法和说明
ImplementationType	extend`()` 与父类函数的作用一样
`int`	getNumberOfDimensions`()` 与父类函数的作用一样
`int[]`	toArray`()` 获取到坐标的每一个维度的值组成的数组

FloatingPointCoordinates

限定符和类型	方法和说明
ImplementationType	extend`()` 与父类函数的作用一样
`int`	getNumberOfDimensions`()` 与父类函数的作用一样
`int[]`	toArray`()` 获取到坐标的每一个维度的值组成的数组

浮点类型操作数

能够通过一个浮点数组创建出来其对应的操作数对象，操作数对象中具有强大的计算功能。

package zhao.algorithmMagic;



import zhao.algorithmMagic.operands.matrix.DoubleMatrix;
import zhao.algorithmMagic.operands.vector.DoubleVector;

import java.util.Arrays;

public class MAIN1 
    public static void main(String[] args) 
        // 构建出Java数组
        double[] ints1 = new double[]1, 2, 3, 4, 5, 6;
        double[] ints2 = new double[]10, 20, 30, 40, 50, 60;
        // 构建出整形向量
        DoubleVector parse1 = DoubleVector.parse(ints1);
        DoubleVector parse2 = DoubleVector.parse(ints2);
        // 对向量进行加减基本运算，并打印结果
        System.out.println(">>> 1: =========");
        System.out.println(parse2.add(parse1));
        System.out.println(parse2.diff(parse1));
        // 进行连减
        System.out.println(parse2.diff(parse1).diff(parse1).diff(parse1));

        // 进行内积与外积计算
        System.out.println(">>> 2: =========");
        System.out.println(parse2.innerProduct(parse1));
        System.out.println(parse2.multiply(parse1));

        // 将两个向量对象组合成为矩阵
        DoubleMatrix matrix = DoubleMatrix.parse(parse1, parse2);
        // 进行特征选择，在这里我们选择清理掉特征突出性较小排名中，前70% 的维度
        System.out.println(">>> 3: =========");
        DoubleMatrix integerMatrix = matrix.featureSelection(0.7);
        // 打印去除结果
        System.out.println(integerMatrix);

        // 获取到向量中的数组对象
        System.out.println(">>> 4: =========");
        double[] ints3 = parse1.copyToNewArray();
        double[] ints4 = parse2.copyToNewArray();
        double[] ints5 = parse1.toArray();
        double[] ints6 = parse2.toArray();
        // 修改 ints5 ints6 两个数组的数值
        // 会导致ints1 ints2 以及其所有对象发生变化，这是因为AS允许用户直接从对象中获取到数组
        ints5[1] = 1024;
        ints6[1] = 1024;
        System.out.println(Arrays.toString(ints1));
        System.out.println(Arrays.toString(ints2));
        // 而修改 ints3 ints4 则不会发生这种情况
        // 因此在需要对数组进行修改的时候，建议使用copyToNewArray
        ints3[1] = 2048;
        ints4[1] = 2048;
        System.out.println(Arrays.toString(ints1));
        System.out.println(Arrays.toString(ints2));

整数类型操作数

package zhao.algorithmMagic;

import zhao.algorithmMagic.operands.matrix.IntegerMatrix;
import zhao.algorithmMagic.operands.vector.IntegerVector;

import java.util.Arrays;

public class MAIN1 
    public static void main(String[] args) 
        // 构建出Java数组
        int[] ints1 = new int[]1, 2, 3, 4, 5, 6;
        int[] ints2 = new int[]10, 20, 30, 40, 50, 60;
        // 构建出整形向量
        IntegerVector parse1 = IntegerVector.parse(ints1);
        IntegerVector parse2 = IntegerVector.parse(ints2);
        // 对向量进行加减基本运算，并打印结果
        System.out.println(">>> 1: =========");
        System.out.println(parse2.add(parse1));
        System.out.println(parse2.diff(parse1));
        // 进行连减
        System.out.println(parse2.diff(parse1).diff(parse1).diff(parse1));

        // 进行内积与外积计算
        System.out.println(">>> 2: =========");
        System.out.println(parse2.innerProduct(parse1));
        System.out.println(parse2.multiply(parse1));

        // 将两个向量对象组合成为矩阵
        IntegerMatrix matrix = IntegerMatrix.parse(parse1, parse2);
        // 进行特征选择，在这里我们选择清理掉特征突出性较小排名中，前70% 的维度
        System.out.println(">>> 3: =========");
        IntegerMatrix integerMatrix = matrix.featureSelection(0.7);
        // 打印去除结果
        System.out.println(integerMatrix);
        // 获取到向量中的数组对象
        System.out.println(">>> 4: =========");
        int[] ints3 = parse1.copyToNewArray();
        int[] ints4 = parse2.copyToNewArray();
        int[] ints5 = parse1.toArray();
        int[] ints6 = parse2.toArray();
        // 修改 ints5 ints6 两个数组的数值
        // 会导致ints1 ints2 以及其所有对象发生变化
        // 这是因为AS允许用户直接从对象中获取到数组
        ints5[1] = 1024;
        ints6[1] = 1024;
        System.out.println(Arrays.toString(ints1));
        System.out.println(Arrays.toString(ints2));
        // 而修改 ints3 ints4 则不会发生这种情况
        // 因此在需要对数组进行修改的时候，建议使用copyToNewArray
        ints3[1] = 2048;
        ints4[1] = 2048;
        System.out.println(Arrays.toString(ints1));
        System.out.println(Arrays.toString(ints2));

复数

package zhao.algorithmMagic;

import zhao.algorithmMagic.operands.ComplexNumber;

public class MAIN1 
    public static void main(String[] args) 
        // 创建2个复数对象
        ComplexNumber complexNumber1 = ComplexNumber.parse("1 + 2i");
        ComplexNumber complexNumber2 = ComplexNumber.parse(2, 1);
        // 打印两个复数对象
        System.out.println(">>> 1: =========");
        System.out.println(complexNumber1);
        System.out.println(complexNumber2);
        System.out.println(
                "complexNumber1 的实部 = " + complexNumber1.getReal() +
                        "\\tcomplexNumber1 的虚部 = " + complexNumber1.getImaginary()
        );
        // 对两个复数对象进行基本运算
        System.out.println(">>> 2: =========");
        System.out.println(complexNumber1.add(complexNumber2));
        System.out.println(complexNumber1.diff(complexNumber2));
        System.out.println(complexNumber1.multiply(complexNumber2));
        System.out.println(complexNumber1.divide(complexNumber2));
        // 获取到两个复数的共轨
        System.out.println(">>> 3: =========");
        System.out.println(complexNumber1.conjugate());
        System.out.println(complexNumber2.conjugate());

特征提取

特征提取的本质就是将一份计算机中并不认识的数据，转换成为向量或矩阵这种计算机可以用来计算的对象，使得后续的数据处理流程不会因此受挫，AS库中的特征提取主要针对字符串类的数据，接下来就进行一下演示！

字典特征提取

字典特征提取是将每一个数据作为矩阵中的一个行向量，AS库中采用one-hot编码的形式将数据进行转换，接下来看一个实际的例子。

代码与运行结果

package zhao.algorithmMagic;

import zhao.algorithmMagic.algorithm.featureExtraction.DictFeatureExtraction;
import zhao.algorithmMagic.operands.matrix.ColumnIntegerMatrix;

public class MAIN1 
    public static void main(String[] args) 
        // 获取到字典特征提取组件
        DictFeatureExtraction dict = DictFeatureExtraction.getInstance("dict");
        // 构造一个需要被提取的数组，其中每一个元素都会作为一个行向量，每一个行内数据会作为一个列字段
        String[] strings = 
                "cat", "dog", "turtle", "fish", "cat"
        ;
        // 开始提取特征矩阵
        ColumnIntegerMatrix extract = dict.extract(strings);
        // 打印矩阵
        System.out.println(extract);
        // 打印矩阵的hashMap形式
        extract.toHashMap().forEach((key, value) -> System.out.println(value.toString() + '\\t' + key));

接下来是运行结果，在运行结果中可以看到，针对所有的行数据都构建成为了一个数组，每一个数组都是一个向量对象，可以看到其中数据对应的值在每一列都是对应的，其中1代表所属标记，0代表不属于。

简单来说就是在进行字典特征提取之前将每一个行数据作为了一种类别，在构造的时候，为对应类别打上属于标记！

通过toHashMap函数可以获取到不同行数据对应的向量值。

词频特征提取

词频特征提取，顾名思义就是词频统计，一句话中的词频往往可以体现出这句话要表达的意义，本次就进行AS库中的词频特征向量提取实现。

代码与运行结果

package zhao.algorithmMagic;

import zhao.algorithmMagic.algorithm.featureExtraction.WordFrequency;
import zhao.algorithmMagic.operands.matrix.ColumnIntegerMatrix;

public class MAIN1 
    public static void main(String[] args) 
        // 获取到词频特征提取组件
        WordFrequency word = WordFrequency.getInstance("word");
        // 构建一些被统计的文本
        String[] data = 
                "I love you, Because you are beautiful.",
                "I need you. Because I'm trapped"
        ;
        // 开始统计
        ColumnIntegerMatrix extract1 = word.extract(data);
        // 打印结果
        System.out.println(extract1);

下面是运行结果，可以看到它返回的是一个具有行列的整形矩阵，在矩阵中，列字段代表每一个被提取的文本，在矩阵中的行字段代表每一种词，其中矩阵的数值就是代表的对应词的出现频率。

特征选择

基于冗余排名比例去除

代码与运行结果

特征选择是所有矩阵中都可以使用的一个函数，其于1.14版本后开始支持，特征选择能够将诸多的冗余特征去除掉，AS库中的矩阵进行的特征选择都是基于行向量的操作，接下来是矩阵冗余特征去除实现！

package zhao.algorithmMagic;

import zhao.algorithmMagic.operands.matrix.DoubleMatrix;

public class MAIN1 
    public static void main(String[] args) 
        // 创建一个矩阵对象，其中包含一些不具有特征突出行的向量
        DoubleMatrix doubleMatrix = DoubleMatrix.parse(
                new double[]1, 2, 3, 4, 5, 6,
                new double[]1, 2, 1, 1, 2, 1, // 过于稳定，缺少特征突出性
                new double[]10, 20, 30, 40, 50, 60
        );
        System.out.println(doubleMatrix);
        // 开始调用特征去除函数，去除其中百分之40的行，并返回新矩阵
        DoubleMatrix doubleMatrix1 = doubleMatrix.featureSelection(0.4);
        System.out.println(doubleMatrix1);

基于相关系数去除

代码与运行结果

package zhao.algorithmMagic;

import zhao.algorithmMagic.operands.matrix.ColumnDoubleMatrix;

public class MAIN1 
    public static void main(String[] args) 
        // 创建一个矩阵对象，其中包含一些相关联的数据，本次要求将与年龄相关联的数据全部删掉
        ColumnDoubleMatrix columnDoubleMatrix = ColumnDoubleMatrix.parse(
                new String[]"人员编号", "人员年龄", "人员工资(k)", "幸福指数",
                new String[]"N1", "N2", "N3", "N4", "N5",
                new double[]1, 25, 14, 16,
                new double[]2, 45, 12, 10,
                new double[]3, 33, 13, 12,
                new double[]4, 42, 16, 17,
                new double[]5, 25, 12, 10
        );
        System.out.println(columnDoubleMatrix);
        // 转置矩阵
        columnDoubleMatrix = columnDoubleMatrix.transpose();
        System.out.println(columnDoubleMatrix);
        // 开始去除与第3行正相关的所有维度数据 TODO 需要保证相关维度的值接近！
        ColumnDoubleMatrix columnDoubleMatrix1 = columnDoubleMatrix.deleteRelatedDimensions(2, 0.5, 1);
        // 打印新矩阵
以上是关于AlgorithmStar机器学习AS机器学习库特征工程使用说明文档的主要内容，如果未能解决你的问题，请参考以下文章 
 机器学习Matplotlib 快速入门笔记
 pandas dataframe 做机器学习训练数据=》直接使用iloc或者as_matrix即可
 机器学习的8篇文章
 程序员用于机器学习编程的Python 数据处理库 pandas 进阶教程
 python机器学习数学
 Spark-数据源及机器学习算法部署