AdaBoost算法和java实现

最新推荐文章于 2021-03-03 15:54:56 发布
最新推荐文章于 2021-03-03 15:54:56 发布
阅读量480 收藏 3
点赞数
分类专栏： 数据挖掘 文章标签： 机器学习 数据挖掘 算法

AdaBoost算法和java实现

算法描述

输入：训练数据集这里写图片描述,其中 xi ∈ χ ⊆ Rn , yi ∈ {-1,+1};弱学习算法； 
输出：最终分类器G(x)。

  1. 初始化训练集数据的权值分布 
    D1 =( w11 ,…, wiN ),  w1i =1/N, i=1,2…,N

  2. 对m=1,2,…,M

    • (a)使用具有权值分布 Dm 的训练数据集学习，得到基本分类器 
      Gm(x):χ−−> {-1,+1}

    • (b) 计算 Gm(x) 在训练数据集上的分类误差率 
      em= P(Gm(xi)≠yi)=∑Ni=1wmiI(Gm(xi)≠yi)

    • (c) 计算 Gx 的系数 
      αm=12log1−emem 这里的对数是自然对数。

  • (d)更新训练数据集的权值分布 
    Dm+1=(wm+1,1,...wm+1,N)

    wm+1,i=wmiZmexp(−αmyiGm(xi)),i=1,2,...,N  
    , Zm 是规范化因子

    Zm=∑Ni=1wmiexp(−αmyiGm(xi))  
    它是 Dm+1 成为一个概率分布。

3. 构建基本分类器的线性组合

f(x)= ∑Mm+1αmGm(x) 

得到最终分类器

G(x)=sign(f(x))=sign(∑Mm=1αmGm(x))

举例说明

数据如下 
这里写图片描述 
当m=1时， 
根据以上的公式有 D1 =( w1i,w2i,...,w2i ), w1i=0.1,i=1,2,...,10 然后在权值分布为 D1 的训练数据集上，阈值v取2.5时分类的误差率最低，故分类器为 
注意 
在训练集上的误差率 e1 =3*0.1(3表示有三个分类错误的数据，0.1对应权值数组 D1 上的值)

按照（c）中的公式据算  α1=12log1−e1e1 =0.4236

更新数据的权值分布： 
D2 =(0.07143,0.07143,0.07143,0.07143,0.07143,0.07143,0.16667,0.16667,0.16667,0.07143)()大家可以发现被错误分类的点的权值被加大了 
f1(x)=α1G1(x) =0.4236 G1(x)  
分类器sign[ f1(x) ]在训练数据集上有三个错误分类点。

当m=2时， 
-在权值分布为 D2 的训练数据集上 ，阈值v是8.5时分类误差率最低，基本分类器为

这里写图片描述 
-  G2(x) 在训练数据集上的误差率 e2 =0.2143 
- 计算 α2 =0.6496 
-更新训练数据集权值分布： 
D3 =(0.455，0.455，0.455，0.1667，0.1667，0.1667,0.1060,0.1060,0.1060,0.0455) 
f2(x) =0.4236 G1(x)+0.6496G2(x)  
分类器sign[ f2(x) ]在训练数据集上有三个错误分类点。

当m=3时， 
-在权值分布为 D2 的训练数据集上 ，阈值v是8.5时分类误差率最低，基本分类器为

这里写图片描述 
-  G2(x) 在训练数据集上的误差率 e3 =0.1820 
- 计算 α3 =0.7514 
-更新训练数据集权值分布： 
D3 =(0.125，0.125，0.125，0.102，0.102，0.102,0.065,0.065,0.065,0.125) 
f2(x) =0.4236 G1(x)+0.6496G2(x)+0.7514G3(x)  
分类器sign[ f2(x) ]在训练数据集上有0个错误分类点。 
故： G(x)=sign[f3(x)]=sign[0.4236G1(x)+0.6496G2(x)+0.7514G3(x)] 

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class Test08 {
    public  ArrayList<String> list=new ArrayList<String>();
    public static final double k = 0.5;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Test08 test=new Test08();
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        map.put(0, 1);
        map.put(1, 1);
        map.put(2, 1);
        map.put(7, 1);
        map.put(5, -1);
        map.put(6, 1);
        map.put(8, 1);
        map.put(9, -1);
        map.put(3, -1);
        map.put(4, -1);
        System.out.println(test.adaBoost(test.sortMapByKey(map)));
    }

    public TreeMap<Integer, Integer>  sortMapByKey(Map<Integer, Integer> oriMap) {
        if (oriMap == null || oriMap.isEmpty()) {
            return null;}
        TreeMap<Integer, Integer> sortedMap = new TreeMap<Integer, Integer>(new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                // 如果有空值，直接返回0
                if (o1 == null || o2 == null)
                    return 0;
                return String.valueOf(o1).compareTo(String.valueOf(o2));
            }
        });
        sortedMap.putAll(oriMap);
        return sortedMap;
    }

    public Map<Double,Double> adaBoost(TreeMap<Integer, Integer> data) {
        Map<Double,Double> result=new HashMap<Double,Double>();
        int dataLenght=data.size();
        double[] weight = new double[dataLenght];
        //初始化权值数组
        for (int i = 0; i < dataLenght; i++) {
            weight[i]=1.0/dataLenght;
        }

        double grade1 = 0;
        double grade2 = 0;
        //double flag = 0;
        String f=null;
        double current=0;
        double ah=0;
        double low=data.firstKey();//选取最小的特征值
        double high=data.lastKey();//选取最大的特征值
        //迭代50次
        for(int it=0;it<50;it++){
            double min=1000;
            double flag=low;//用来标记比较优的特征的值
            while(flag<=high){
                int index = 0;// 用来索引权值数组
                grade1=0;
                grade2=0;
                for (Integer en : data.keySet()) {
                    //大于某一个特征值则为一时
                    if(GreatToOne(en, flag)!=data.get(en)){
                        grade1+=weight[index];
                    }
                    //小于某一个特征值则为一时
                    if(LessToOne(en, flag)!=data.get(en)){
                        grade2+=weight[index];
                    }   
                    index++;
                }
                //选取最优的特征值
                if (grade1 < min) {
                    min = grade1;
                    current = flag;
                    f="great";//用来标记采用的哪一个函数（GreatToOne or LessToOne）
                }
                if(grade2<min){
                    min=grade2;
                    current = flag;
                    f="less";
                }
                flag+=k;//将用来分类的特征值增加k
            }
            ah=0.5*Math.log((1-min)/min);
            double totle=0;
            int j=0;
            //
            for(Integer en:data.keySet()){
                if(f.equals("great")){
                    totle+=weight[j++]*Math.exp(-ah*data.get(en)*GreatToOne(en,current));
                }
                else{
                    totle+=weight[j++]*Math.exp(-ah*data.get(en)*LessToOne(en,current));
                }

            }
            j=0;
            for(Integer en:data.keySet()){
                if(f.equals("great")){
                    weight[j]=weight[j]*Math.exp(-ah*data.get(en)*GreatToOne(en,current))/totle;
                }
                else{
                    weight[j]=weight[j]*Math.exp(-ah*data.get(en)*LessToOne(en,current))/totle;
                }
                j++;
            }
        result.put(ah, current);
        list.add(f);
        //错误率为零，则退出
        if(calc(result,data)==0) break;
        }
    return result;
    }
    private int calc(Map<Double, Double> result, TreeMap<Integer, Integer> data) {
        // TODO Auto-generated method stub
        int count=0;

        for(Integer en:data.keySet()){
            double sum=0;int index=0;
            for(Double d:result.keySet()){
                if(list.get(index).equals("great")){
                    sum+=d*GreatToOne(en,result.get(d));
                }
                else{
                    sum+=d*LessToOne(en,result.get(d));
                }   
                index++;            
            }
            if(sum>0&&data.get(en)==-1) {
                count++;
            }
            if(sum<0&&data.get(en)==1){
                count++;
            }

        }
        if(count==0){
            return 0;
            }
        else{
            return 1;
        }
    }

    public int GreatToOne(int x,double flag){
        if(x>flag) {
            return 1;
        }else{
            return -1;
        }
    }
    public int LessToOne(int x,double flag){
        if(x<flag) {
            return 1;
        }else{
            return -1;
        }
    }
}


结果如下： 

这里写图片描述


liqiuguo
关注
专栏目录
adaboost算法java_Adaboost 算法实例解析
weixin_35651995的博客
02-16 359
Adaboost 算法实例解析1 Adaboost的原理1.1 Adaboost基本介绍AdaBoost，是英文"Adaptive Boosting"(自适应增强)的缩写，由Yoav Freund和Robert Schapire在1995年提出。Adaboost是一种迭代算法，其核心思想是针对同一个训练集训练不同的分类器(弱分类器)，然后把这 Adaboost 些弱分类器集合起来，构成一个更强的最...
AdaBoost算法java实现
03-25
AdaBoost算法java实现，附带测试用例通过。 AdaBoost算法描述见书Foundations of Machine Learning P122
java实现adaboost算法
iteye_13839的博客
07-04 290
adaboost算法的主要原理是训练若干个弱分类器，根据训练结果赋予它们不同的权值，最后再将这些弱分类器组合起来，形成一个强分类器，adaboost的基本原理在http://wenku.baidu.com/view/49478920aaea998fcc220e98.html###中已经有很详细的描述 这里使用上一篇博客中的感知器算法作为弱分类器，代码如下： 首先是adaboost算法的结果...
机器学习知识点(十六)集成学习AdaBoost算法Java实现
医疗影像检索
03-13 2710
理解http://blog.csdn.net/fjssharpsword/article/details/61913092中AdaBoost算法，从网上找了一套简单的代码加以理解。 1、基分类器，实现一个简单的分类 1）对象类 package sk.adaboost; public class Instance { public double[] dim; //各个维度值 publi
Adaboost的java实现
02-22 3703
实体类 /** * 样例 * @author Administrator * */ public class Instance { public double[] dim; //各个维度值 public int label; //类别标号 public Instance(double[] dim, int label) { this.dim = dim; this.
AdaBoost算法的Java代码实现与优化.zip
04-30
AdaBoost算法Java实现提供了高效的分类解决方案。该资源包含完整的Java源代码、教程文档、示例数据和测试脚本，旨在帮助用户快速理解和应用AdaBoost算法。适用于对机器学习感兴趣的开发者、数据科学家以及需要提升...
AdaBoost算法在Java中的高效实现.zip
最新发布
04-30
AdaBoost算法Java实现提供了高效的分类解决方案。该资源包含完整的Java源代码、教程文档、示例数据和测试脚本，旨在帮助用户快速理解和应用AdaBoost算法。适用于对机器学习感兴趣的开发者、数据科学家以及需要提升...
AdaBoost算法Java实现：机器学习入门指南.zip
04-30
AdaBoost算法Java实现提供了高效的分类解决方案。该资源包含完整的Java源代码、教程文档、示例数据和测试脚本，旨在帮助用户快速理解和应用AdaBoost算法。适用于对机器学习感兴趣的开发者、数据科学家以及需要提升...
adaboost算法java源码-adaboost-trading-system:基于adaboost算法的交易系统，使用组合的弱分类器进行预
06-04
adaboost算法java源码adaboost-交易系统 基于 adaboost 算法的交易系统，使用组合的弱分类器进行预测。 注意：首先，我应该谈谈这个计划及其实施动机。 投资有一定风险，请慎重决定。 我现在从未将这个程序应用于...
AdaBoost算法java实现统计学习方法例子
08-10
java实现，Adaboost算法，统计学习方法书上简单例子
adaboost分类java源码
02-26
adaboost方法实现分类的完整代码，准确率很高，可直接运行，可扩展到多分类
Adaboost:Adaboost（自适应提升）元算法的 Java 实现（机器学习）
06-17
Adaboost AdaBoost 是“Adaptive Boosting”的缩写，是一种机器学习元算法。 它可以与许多其他类型的学习算法结合使用，以提高它们的性能。 其他学习算法（“弱学习器”）的输出被组合成一个加权和，代表提升分类器的最终输出 执行 我更喜欢循环训练文件行而不是将所有文件加载到内存中，因此它必须适用于非常大的文件。 首先，学习文件必须在 PSV（管道分隔值）中。 resources/trainingSamples.psv 中已存在示例文件最后一列作为实体类类型必须为 { 1 , -1 } “目前仅支持二进制分类” 用法 File file = new File ( " resources/trainSamples.psv " ); Adaboost boosting = Adaboost . train(file, 10 , 10 , 0 ); int l
adaboost人脸检测 （java）
11-07
用java实现adaboost 人脸检测
用java实现的大数据分析 ID3算法
09-12
这个例子来源于Quinlan的论文。 假设，有种户外活动。该活动能否正常进行与各种天气因素有关。不同的天气因素组合会产生两种后果，也就是分成2类：能进行活动或不能。我们用P表示该活动可以进行，N表示该活动无法进行。 下表描述样本集合是不同天气因素对该活动的影响。 Attribute class outlook temperature（温度） humidity （湿度） windy（风） Play --------------------------------------------------------- sunny hot high false N sunny hot high true N sunny mild high false N sunny cool normal false P sunny mild normal true P rain mild high false P rain cool normal false P rain cool normal true N rain mild normal false P rain mild high true N overcast hot high false P overcast cool normal true P overcast mild high true P overcast hot normal false P 分析如以上数据可得出如下决策树（横着看） |--outlook --|--rainy --|--windy --|--TRUE --|--NO -- |--FALSE --|--YES -- |--sunny --|--humidity --|--high --|--NO -- |--normal --|--YES -- |--overcast --|--YES --
adaboost java_机器学习算法：AdaBoost
weixin_35461822的博客
03-03 171
AdaBoost算法(Adaptive Boost)的核心思想是：如果一个弱分类器的分类效果不好，那么就构建多个弱分类器，综合考虑它们的分类结果和权重来决定最终的分类结果。很多人认为AdaBoost是监督学习中最强大的两种算法之一(另一个是支持向量机SVM)。AdaBoost的训练过程如下：为每个训练样本初始化相同的权重；针对训练样本及权重，找到一个弱分类器；计算出这个弱分类器的错误率ε与权重α；...
adaboost java_Adaboost的java实现 | 学步园
weixin_42502382的博客
02-19 125
实体类/*** 样例* @author Administrator**/public class Instance {public double[] dim;//各个维度值public int label;//类别标号public Instance(double[] dim, int label) {this.dim = dim;this.label = label;}}父类分类器public a...
adaboost算法java_AdaBoost装袋提升算法
weixin_27744023的博客
02-22 193
介绍在介绍AdaBoost算法之前，需要了解一个类似的算法，装袋算法(bagging)，bagging是一种提高分类准确率的算法，通过给定组合投票的方式，获得最优解。比如你生病了，去n个医院看了n个医生，每个医生给你开了药方，最后的结果中，哪个药方的出现的次数多，那就说明这个药方就越有可能性是最由解，这个很好理解。而bagging算法就是这个思想。算法原理而AdaBoost算法的核心思想还是基于b...
adaboost算法代码 java_AdaBoost算法和java实现
weixin_34508497的博客
02-13 228
AdaBoost算法和java实现算法描述输入：训练数据集,其中xi∈χ⊆Rn,yi∈{-1,+1};弱学习算法； 输出：最终分类器G(x)。 初始化训练集数据的权值分布 D1=(w11,…,wiN),w1i=1/N, i=1,2…,N对m=1,2,…,M(a)使用具有权值分布Dm的训练数据集学习，得到基本分类器 Gm(x):χ−−>{-1,+1}(b) 计算Gm(x)在训练数据集上...
adaboost算法java代码_04-04 AdaBoost算法代码(鸢尾花分类)
06-02
好的，以下是使用Java实现的AdaBoost算法代码，用于鸢尾花分类： ```java import java.util.ArrayList; import java.util.Collections; public class AdaBoost { // 训练数据集 private ArrayList<ArrayList<Double>> dataSet; // 类别标签 private ArrayList<Integer> labels; // 弱分类器数目 private int weakNum; // 训练好的弱分类器集合 private ArrayList<WeakClassifier> weakClassifiers; // AdaBoost构造函数 public AdaBoost(ArrayList<ArrayList<Double>> dataSet, ArrayList<Integer> labels, int weakNum) { this.dataSet = dataSet; this.labels = labels; this.weakNum = weakNum; this.weakClassifiers = new ArrayList<>(); } // 训练分类器 public void train() { int size = dataSet.size(); // 初始化权重向量 ArrayList<Double> weights = new ArrayList<>(); for (int i = 0; i < size; i++) { weights.add(1.0 / size); } // 训练 weakNum 个弱分类器 for (int i = 0; i < weakNum; i++) { // 训练单个弱分类器 WeakClassifier weakClassifier = new WeakClassifier(dataSet, labels, weights); weakClassifier.train(); // 计算错误率 double error = 0.0; for (int j = 0; j < size; j++) { if (weakClassifier.predict(dataSet.get(j)) != labels.get(j)) { error += weights.get(j); } } // 计算弱分类器权重 double alpha = 0.5 * Math.log((1 - error) / error); weakClassifier.setAlpha(alpha); // 更新权重向量 for (int j = 0; j < size; j++) { if (weakClassifier.predict(dataSet.get(j)) == labels.get(j)) { weights.set(j, weights.get(j) * Math.exp(-alpha)); } else { weights.set(j, weights.get(j) * Math.exp(alpha)); } } // 归一化权重向量 double sum = 0.0; for (int j = 0; j < size; j++) { sum += weights.get(j); } for (int j = 0; j < size; j++) { weights.set(j, weights.get(j) / sum); } // 将训练好的弱分类器加入集合 weakClassifiers.add(weakClassifier); } } // 预测分类结果 public int predict(ArrayList<Double> data) { double sum = 0.0; for (WeakClassifier wc : weakClassifiers) { sum += wc.predict(data) * wc.getAlpha(); } if (sum > 0) { return 1; } else { return -1; } } // 测试分类器 public void test(ArrayList<ArrayList<Double>> testData, ArrayList<Integer> testLabels) { int errorNum = 0; int size = testData.size(); for (int i = 0; i < size; i++) { if (predict(testData.get(i)) != testLabels.get(i)) { errorNum++; } } double accuracy = 1 - (double) errorNum / size; System.out.println("Accuracy: " + accuracy); } // 主函数 public static void main(String[] args) { // 读取数据集 ArrayList<ArrayList<Double>> dataSet = Util.loadDataSet("iris.data"); // 打乱数据集顺序 Collections.shuffle(dataSet); // 获取标签 ArrayList<Integer> labels = new ArrayList<>(); for (ArrayList<Double> data : dataSet) { if (data.get(data.size() - 1) == 1) { labels.add(1); } else { labels.add(-1); } } // 划分训练集和测试集 ArrayList<ArrayList<Double>> trainData = new ArrayList<>(); ArrayList<ArrayList<Double>> testData = new ArrayList<>(); ArrayList<Integer> trainLabels = new ArrayList<>(); ArrayList<Integer> testLabels = new ArrayList<>(); for (int i = 0; i < dataSet.size(); i++) { if (i % 5 == 0) { testData.add(dataSet.get(i)); testLabels.add(labels.get(i)); } else { trainData.add(dataSet.get(i)); trainLabels.add(labels.get(i)); } } // 训练 AdaBoost 分类器 AdaBoost adaBoost = new AdaBoost(trainData, trainLabels, 10); adaBoost.train(); // 测试分类器 adaBoost.test(testData, testLabels); } } ``` 需要注意的是，此代码中的 `WeakClassifier` 类是用于实现单个弱分类器的训练和预测的，需要自行实现。同时，数据集的加载和处理部分也需要根据实际情况进行修改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值