Weka 算法总结以及接口使用

这个软件一般数学系用得多、引入  weka-stable 可以使用里面的算法接口、也可以直接启动他的窗体，他的支持算法比较全面要实现一般的机器学习算法或者改造植入到自己的系统都可以参考这个算法库。像一些小型的风控、数据分析等业务没必要使用 spark 等大数据平台的情况下比较有用、同时也支持可视化：

训练一个kmeans以及可视化：

    public static void visualizeClusters(Instances data, SimpleKMeans clusterer) throws Exception {
        ClusterEvaluation eval = new ClusterEvaluation();
        eval.setClusterer(clusterer);
        eval.evaluateClusterer(data);

        ClustererAssignmentsPlotInstances plotInstances = new ClustererAssignmentsPlotInstances();
        plotInstances.setClusterer(clusterer);
        plotInstances.setInstances(data);
        plotInstances.setClusterEvaluation(eval);
        plotInstances.setUp();

        VisualizePanel vp = new VisualizePanel();
        vp.setName("Cluster Visualization");
        vp.addPlot(plotInstances.getPlotData(clusterer.getClass().getName()));

        JFrame jf = new JFrame("Weka Clusterer Visualize: " + vp.getName());
        jf.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        jf.setSize(800, 600);
        jf.getContentPane().setLayout(new BorderLayout());
        jf.getContentPane().add(vp, BorderLayout.CENTER);
        jf.setVisible(true);
    }

可视化如下：

也可以界面操作：

import weka.gui.Main;
public class WekaGui {
    public static void main(String[] args) {
        Main.main(new String[]{});
    }
}

就会弹出界面：

下面是 Weka 支持的算法：
 

关联算法：

算法名称	算法描述	Java 类
Apriori	经典关联规则挖掘算法，基于频繁项集先验性质。	weka.associations.Apriori
FilteredAssociator	在应用关联规则学习之前进行过滤操作的关联算法。	weka.associations.FilteredAssociator
FPGrowth	高效的频繁模式挖掘算法，通过构建 FP 树实现频繁项集的发现。	weka.associations.FPGrowth
GeneralizedSequentialPatterns	用于序列模式挖掘，发现数据中的序列规律。	weka.associations.GeneralizedSequentialPatterns
PredictiveApriori	Apriori 算法的扩展，专注于预测缺失属性值。	weka.associations.PredictiveApriori
Tertius	关联规则挖掘算法，用于发现数据中的关联性。	weka.associations.Tertius

聚类算法：

算法名称	算法描述	Java 类
CLOPE	基于模糊逻辑的聚类算法，用于发现模糊的聚类结构。	weka.clusterers.CLOPE
Cobweb	一种增量式聚类算法，用于处理连续数据。	weka.clusterers.Cobweb
DBSCAN	密度聚类算法，根据样本点分布的密度进行聚类。	weka.clusterers.DBSCAN
EM	期望最大化算法，用于高斯混合模型的聚类。	weka.clusterers.EM
FarthestFirst	初始质心选择算法，选择距离最远的点作为初始质心。	weka.clusterers.FarthestFirst
FilteredClusterer	在应用聚类算法之前进行过滤操作的聚类算法。	weka.clusterers.FilteredClusterer
HierarchicalClusterer	层次聚类算法，通过构建聚类层次树进行聚类。	weka.clusterers.HierarchicalClusterer
MakeDensityBasedClusterer	基于密度的聚类算法，根据数据密度进行聚类。	weka.clusterers.MakeDensityBasedClusterer
OPTICS	基于密度的聚类算法，生成数据点的密度图。	weka.clusterers.OPTICS
SIB	数据流聚类算法，用于处理数据流中的聚类任务。	weka.clusterers.SIB
SimpleKMeans	KMeans 聚类算法，通过最小化簇内平方和实现聚类。	weka.clusterers.SimpleKMeans
XMeans	KMeans 变体，自动确定最优的簇数目。	weka.clusterers.XMeans

贝叶斯：

算法名称	算法描述	Java 类
AODE	属性特定独立的贝叶斯分类器。	weka.classifiers.bayes.AODE
AODEsr	属性特定独立的贝叶斯分类器，使用平滑技术。	weka.classifiers.bayes.AODEsr
BayesLogisticRegression	贝叶斯逻辑回归分类器，基于 Logistic Regression 模型。	weka.classifiers.bayes.BayesLogisticRegression
BayesNet	贝叶斯网络分类器，使用贝叶斯网络模型进行分类。	weka.classifiers.bayes.BayesNet
ComplementNativeBayes	补充型朴素贝叶斯分类器，处理非平衡数据集。	weka.classifiers.bayes.ComplementNativeBayes
DMNBtext	多项式朴素贝叶斯分类器，用于处理文本数据。	weka.classifiers.bayes.DMNBtext
HNB	增强型朴素贝叶斯分类器，结合了属性和类别的信息。	weka.classifiers.bayes.HNB
NativeBayes	朴素贝叶斯分类器，基于属性的条件独立性假设。	weka.classifiers.bayes.NaiveBayes
NativeBayesMultinomial	多项式朴素贝叶斯分类器，适用于多项离散数据。	weka.classifiers.bayes.NaiveBayesMultinomial
NativeBayesMultinomialUpdateable	可更新的多项式朴素贝叶斯分类器，适用于流式数据。	weka.classifiers.bayes.NaiveBayesMultinomialUpdateable
NativeBayesSimple	简单朴素贝叶斯分类器，用于处理离散数据。	weka.classifiers.bayes.NaiveBayesSimple
NativeBayesUpdateable	可更新的朴素贝叶斯分类器，适用于流式数据。	weka.classifiers.bayes.NaiveBayesUpdateable
WAODE	带权重的属性特定独立的贝叶斯分类器。	weka.classifiers.bayes.WAODE

函数实现：

算法名称	算法描述	Java 类
GaussianProcesses	高斯过程回归算法，用于回归问题。	weka.classifiers.functions.GaussianProcesses
IsotonicRegression	保序回归算法，用于回归问题。	weka.classifiers.functions.IsotonicRegression
LeastMedSq	最小中位数平方回归算法，用于回归问题。	weka.classifiers.functions.LeastMedSq
LibLINEAR	基于 LIBLINEAR 库的线性分类器。	weka.classifiers.functions.LibLINEAR
LibSVM	基于 LIBSVM 库的支持向量机分类器。	weka.classifiers.functions.LibSVM
LinearRegression	线性回归算法，用于回归问题。	weka.classifiers.functions.LinearRegression
Logistic	逻辑回归算法，用于分类问题。	weka.classifiers.functions.Logistic
MultilayerPerceptron	多层感知器神经网络分类器。	weka.classifiers.functions.MultilayerPerceptron
PaceRegression	PACE 回归算法，用于回归问题。	weka.classifiers.functions.PaceRegression
PLSClassifier	偏最小二乘分类器。	weka.classifiers.functions.PLSClassifier
RBFNetwork	径向基函数网络分类器。	weka.classifiers.functions.RBFNetwork
SimpleLogistic	简单逻辑回归算法，用于分类问题。	weka.classifiers.functions.SimpleLogistic
SMO	序列最小优化算法，用于支持向量机分类。	weka.classifiers.functions.SMO
SMOreg	序列最小优化算法，用于支持向量机回归。	weka.classifiers.functions.SMOreg
SPegasos	Pegasos 算法的 Java 实现，用于线性分类。	weka.classifiers.functions.SPegasos
VotedPerceptron	加权感知器分类器。	weka.classifiers.functions.VotedPerceptron
Winnow	Winnow 算法，用于二分类问题。	weka.classifiers.functions.Winnow

LAZY惰性学习：

算法名称	算法描述	Java 类
IB1	IB1 算法，邻居只选择一个最近的实例。	weka.classifiers.lazy.IB1
IBk	IBk 算法，邻居的数量是可调整的。	weka.classifiers.lazy.IBk
KStar	KStar 算法，实现 k-近邻算法。	weka.classifiers.lazy.KStar
LBR	局部贝叶斯规则学习器，结合贝叶斯算法和规则。	weka.classifiers.lazy.LBR
LWL	局部加权学习（Locally Weighted Learning）	weka.classifiers.lazy.LWL

META：

算法名称	算法描述	Java 类
AdaBoostM1	AdaBoost 算法的一种变体，使用多个弱分类器来构建强分类器。	weka.classifiers.meta.AdaBoostM1
AdditiveRegression	加法回归算法，用于回归问题。	weka.classifiers.meta.AdditiveRegression
AttributeSelectedClassifier	使用特征选择的分类器。	weka.classifiers.meta.AttributeSelectedClassifier
Bagging	Bagging 算法，通过对数据集进行有放回的随机采样训练多个模型。	weka.classifiers.meta.Bagging
ClassificationViaClustering	通过聚类进行分类。	weka.classifiers.meta.ClassificationViaClustering
ClassificationViaRegression	通过回归进行分类。	weka.classifiers.meta.ClassificationViaRegression
CostSensitiveClassifier	对分类器进行代价敏感学习，考虑分类错误的代价。	weka.classifiers.meta.CostSensitiveClassifier
CVParameterSelection	通过交叉验证选择参数。	weka.classifiers.meta.CVParameterSelection
Dagging	基于 DAG 结构的 Bagging 算法。	weka.classifiers.meta.Dagging
Decorate	通过生成多个噪声分类器改进性能。	weka.classifiers.meta.Decorate
END	Ensemble of Nested Dichotomies (END) 算法。	weka.classifiers.meta.END
FilteredClassifier	使用过滤器进行分类。	weka.classifiers.meta.FilteredClassifier
Grading	使用子分类器的评分进行组合。	weka.classifiers.meta.Grading
GridSearch	使用网格搜索来优化分类器的参数。	weka.classifiers.meta.GridSearch
LogitBoost	LogitBoost 算法，一种 Boosting 算法的变体。	weka.classifiers.meta.LogitBoost
MetaCost	对代价敏感分类器进行元学习。	weka.classifiers.meta.MetaCost
MultiBoostAB	AdaBoost 算法的变体，用于多类别分类。	weka.classifiers.meta.MultiBoostAB
MultiClassClassifier	多类别分类器，可将多个二进制分类器组合成一个多类别分类器。	weka.classifiers.meta.MultiClassClassifier
MultiScheme	使用多个分类器。	weka.classifiers.meta.MultiScheme
NestedDichotomies	分类的嵌套二分法算法。	weka.classifiers.meta.NestedDichotomies
ClassBalancedND	Class-Balanced Nested Dichotomies (ND) 算法。	weka.classifiers.meta.ClassBalancedND
DataNearBalancedND	Data-Near-Balanced Nested Dichotomies (ND) 算法。	weka.classifiers.meta.DataNearBalancedND
OrdinalClassClassifier	序数分类器，用于有序分类任务。	weka.classifiers.meta.OrdinalClassClassifier
RaceIncrementalLogitBoost	Race-Incremental LogitBoost 算法，用于增量学习。	weka.classifiers.meta.RaceIncrementalLogitBoost
RandomCommittee	随机委员会算法，通过训练多个分类器进行投票。	weka.classifiers.meta.RandomCommittee
RandomSubSpace	随机子空间算法，通过随机选择特征子集进行训练。	weka.classifiers.meta.RandomSubSpace
RegressionByDiscretization	通过将回归问题离散化为分类问题进行学习。	weka.classifiers.meta.RegressionByDiscretization
RotationForest	Rotation Forest 算法，一种 Ensemble 方法。	weka.classifiers.meta.RotationForest
Stacking	Stacking 算法，通过堆叠多个分类器进行学习。	weka.classifiers.meta.Stacking
StackingC	StackingC 算法，Stacking 的变体。	weka.classifiers.meta.StackingC
ThresholdSelector	阈值选择算法，用于选择分类器输出的阈值。	weka.classifiers.meta.ThresholdSelector
Vote	投票算法，通过投票决定最终的分类结果。	weka.classifiers.meta.Vote

MI：

算法名称	算法描述	Java 类
CitationKNN	基于引文的 k 近邻算法。	weka.classifiers.mi.CitationKNN
MDD	多示例多标签学习算法。	weka.classifiers.mi.MDD
MIBoost	多示例 Boosting 算法。	weka.classifiers.mi.MIBoost
MIDD	基于 Diverse Density 的多示例学习算法。	weka.classifiers.mi.MIDD
MIEMDD	多示例学习算法，结合 Diverse Density 和 Example Set 的信息。	weka.classifiers.mi.MIEMDD
MILR	多示例学习算法，使用标签关联的 Logit 模型。	weka.classifiers.mi.MILR
MINND	多示例学习算法，基于最近邻的策略。	weka.classifiers.mi.MINND
MIOptimalBall	多示例学习算法，通过球体进行实例分布建模。	weka.classifiers.mi.MIOptimalBall
MISMO	多示例学习算法，通过学习相似性矩阵进行分类。	weka.classifiers.mi.MISMO
MISVM	多示例学习算法，支持向量机。	weka.classifiers.mi.MISVM
MIWrapper	多示例学习算法的包装器，用于将基本分类器转换为多示例分类器。	weka.classifiers.mi.MIWrapper
SimpleMI	多示例学习算法，使用简单的实例权重。	weka.classifiers.mi.SimpleMI

MISC：

HyperPipes	多分类的支持向量机算法。	weka.classifiers.misc.HyperPipes
SerializedClassifier	序列化的分类器，用于加载已保存的模型。	weka.classifiers.misc.SerializedClassifier
VFI	变量频繁项集算法，用于特征选择。	weka.classifiers.misc.VFI

Ruler：

算法名称	算法描述	Java 类
ConjunctiveRule	由规则组成的模型，通过组合规则进行分类。	weka.classifiers.rules.ConjunctiveRule
DecisionTable	决策表模型，通过规则表进行分类。	weka.classifiers.rules.DecisionTable
DINB	直接从实例中学习的贝叶斯网络。	weka.classifiers.rules.DINB
JRip	基于规则的归纳算法，生成简化的规则集。	weka.classifiers.rules.JRip
M5Rules	使用M5算法生成的规则集模型。	weka.classifiers.rules.M5Rules
NNge	基于元启发式搜索的归纳算法，生成简化的规则集。	weka.classifiers.rules.NNge
OneR	基于单一规则的分类算法，选择最佳单一规则。	weka.classifiers.rules.OneR
PART	由部分规则组成的规则集模型。	weka.classifiers.rules.PART
Prism	基于二维网格的分割算法，生成规则集模型。	weka.classifiers.rules.Prism
Ridor	基于规则的分类算法，生成简化的规则集。	weka.classifiers.rules.Ridor
ZeroR	使用零规则进行分类的简单模型。	weka.classifiers.rules.ZeroR

Tree：

算法名称	算法描述	Java 类
ADTree	预测性模型，通过剪枝的决策树生成。	weka.classifiers.trees.ADTree
BFTree	通过自底向上的构建树生成的决策树。	weka.classifiers.trees.BFTree
DecisionStump	通过一棵深度为1的树生成的决策树。	weka.classifiers.trees.DecisionStump
FT	通过特征选择生成的决策树。	weka.classifiers.trees.FT
ID3	使用ID3算法生成的决策树。	weka.classifiers.trees.ID3
J48	使用C4.5算法生成的决策树。	weka.classifiers.trees.J48
J48graft	在C4.5基础上，使用修剪技术生成的决策树。	weka.classifiers.trees.J48graft
LADTree	通过局部加权回归生成的决策树。	weka.classifiers.trees.LADTree
LMI	通过基于信息理论的分割生成的决策树。	weka.classifiers.trees.LMI
M5P	基于模型树的回归算法，生成的决策树用于回归问题。	weka.classifiers.trees.M5P
NBTree	使用朴素贝叶斯分类器生成的决策树。	weka.classifiers.trees.NBTree
RandomForest	通过随机森林生成的决策树模型。	weka.classifiers.trees.RandomForest
RandomTree	使用随机特征选择生成的决策树。	weka.classifiers.trees.RandomTree
REPTree	基于回归树的决策树生成算法。	weka.classifiers.trees.REPTree
SimpleCart	使用基尼指数进行分割的简单决策树生成算法。	weka.classifiers.trees.SimpleCart
UserClassifier	允许用户定义分类器生成的决策树。	weka.classifiers.trees.UserClassifier

Weka 使用比较简单可以很方便的将机器学习算法嵌入到java应用中：

import weka.classifiers.Evaluation;
import weka.core.Instances;
import weka.core.SerializationHelper;
import weka.core.converters.CSVLoader;
import weka.classifiers.trees.J48;
import weka.filters.Filter;
import weka.filters.unsupervised.instance.RemovePercentage;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;

/**
 *   @desc : weka 决策树分类
 *   @auth : tyf
 *   @date : 2024-03-04  15:16:25
 */
public class WekaDecisionTree {

    // 生成随机训练样本
    public static void generateCsv(String csv){
        Random r = new Random();
        if(new File(csv).exists()){
            return;
        }
        // 写入到本地csv
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(csv, true))) {
            for (int i = 0; i < 10000; i++) {
                double f1 = r.nextDouble()*100;
                double f2 = r.nextDouble()*100;
                double f3 = r.nextDouble()*100;
                double f4 = r.nextDouble()*100;
                String label = "";
                double score = f1*10 + f2*5 + f3*5 - f4*5;
                if(score>=-500&&score<0){ label = "E";}
                else if(score>=0&&score<500){ label = "D";}
                else if(score>=500&&score<1000){ label = "C";}
                else if(score>=1000&&score<1500){ label = "B";}
                else if(score>=1500&&score<2000){ label = "A";}
                String line = f1 +","+ f2 + ","+f3 + ","+f4 + ","+label;
                writer.write(line);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public static void main(String[] args) throws Exception{

        // 样本路径
        String csv = "C:\\Users\\tyf\\Desktop\\data.csv";
        // 模型保存和加载路径
        String module = "C:\\Users\\tyf\\Desktop\\j48.model";

        // 生成随机训练样本
        generateCsv(csv);

        // 读取数据
        CSVLoader loader = new CSVLoader();
        loader.setSource(new File(csv));

        // 数据集 Instances
        Instances data = loader.getDataSet();
        System.out.println("行:"+data.size()+",列:"+data.numAttributes());

        // 最后一列是 label
        data.setClassIndex(data.numAttributes()-1);

        // 划分训练集
        RemovePercentage data_08 = new RemovePercentage();
        data_08.setInputFormat(data);
        data_08.setPercentage(80); // 百分比
        data_08.setInvertSelection(true);

        // 划分验证集
        RemovePercentage data_02 = new RemovePercentage();
        data_02.setInputFormat(data);
        data_02.setPercentage(20); // 百分比
        data_02.setInvertSelection(true);

        Instances trainingData = Filter.useFilter(data, data_08);
        Instances validationData  = Filter.useFilter(data, data_02);

        System.out.println("训练集: "+trainingData.size()+" x "+trainingData.numAttributes());
        System.out.println("验证集: "+validationData.size()+" x "+validationData.numAttributes());

        // 决策树
        J48 tree = new J48();

        // 训练
        tree.buildClassifier(data);

        // 模型评估
        Evaluation evaluation = new Evaluation(trainingData);
        evaluation.evaluateModel(tree, validationData);

        // 打印概要信息
        System.out.println("=== Evaluation Summary ===");
        System.out.println(evaluation.toSummaryString());

        // 模型保存
        SerializationHelper.write(module, tree);
        J48 model = (J48) SerializationHelper.read(module);

        // 使用模型进行单个样本推理
        System.out.println("=== Predict ===");
        for (int i = 0; i < 30; i++) {
            // 预测 label 下标
            double prediction = model.classifyInstance(validationData.get(i));
            // 预测 label
            String predictedClass = validationData.classAttribute().value((int) prediction);
            // 真实的 label
            String trueClass = validationData.instance(i).stringValue(validationData.numAttributes() - 1);
            System.out.println("Sample: " + validationData.get(i) + " , True Class: " + trueClass + " , Predicted Class: " + predictedClass);
        }

    }


}