DATA类
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;
public class Data {
private ArrayList<ArrayList<String>> trainData=new ArrayList<ArrayList<String>>();
public ArrayList<ArrayList<String>> getTrainData() {
return this.trainData;
}
public Data() {
String dataPath="D://javajavajava//dbdt//src//script//data//adult.data.csv";
Scanner in;
try {
in = new Scanner(new File(dataPath));
while (in.hasNext()) {
String line=in.nextLine();
String []strs=line.trim().split(",");
ArrayList<String> tmp=new ArrayList<>();
for(int i=0;i<strs.length;i++)
{
tmp.add(strs[i]);
}
this.trainData.add(tmp);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Data d =new Data();
}
}
TREE类
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
import java.util.spi.TimeZoneNameProvider;
public class Tree {
private Tree leftTree=new Tree();
private Tree rightTree=new Tree();
private double loss=-1;
private int attributeSplit=0;
private String attributeSplitType="";
boolean isLeaf;
double leafValue;
private ArrayList<Integer> leafNodeSet=new ArrayList<>();
public ArrayList<String> getAttributeSet(ArrayList<ArrayList<String>> trainData,int idx)
{
HashSet<String> mySet=new HashSet<>();
ArrayList<String> ans =new ArrayList<>();
for(int i=0;i<trainData.size();i++)
{
mySet.add(trainData.get(i).get(idx));
}
Iterator<String> it=mySet.iterator();
while(it.hasNext())
{
ans.add(it.next());
}
return ans;
}
public boolean myCmpLess(String str1,String str2)
{
if(Integer.parseInt(str1.trim())<=Integer.parseInt(str2.trim()))
return true;
else return false;
}
public double computeLoss(ArrayList<Double> values)
{
double loss=0;
for(int i=0;i<values.size();i++)
{
loss+=values.get(i);
}
double mean=loss/values.size();
loss=0;
for(int i=0;i<values.size();i++)
{
loss+=Math.pow(values.get(i)-mean,2);
}
return Math.sqrt(loss);
}
public double getPredictValue(int K, ArrayList<Integer> subIdx,ArrayList<Double> target) {
double ans=0;
double sum=0,sum1=0;
for(int i=0;i<subIdx.size();i++)
{
sum+=target.get(subIdx.get(i));
}
for(int i=0;i<subIdx.size();i++)
{
sum1+=target.get(subIdx.get(i))*(1-target.get(subIdx.get(i)));
}
ans=(K-1)/K*sum/sum1;
return ans;
}
public double getPredictValue(Tree root)
{
return root.leafValue;
}
public double getPredictValue(Tree root,ArrayList<String> instance,Boolean isDigit[])
{
if(root.isLeaf)
return root.leafValue;
else if(isDigit[root.attributeSplit])
{
if(myCmpLess(instance.get(root.attributeSplit).trim(),root.attributeSplitType))
return getPredictValue(root.leftTree, instance, isDigit);
return getPredictValue(root.rightTree, instance, isDigit);
}
else
{
if(instance.get(root.attributeSplit).trim().equals(root.attributeSplitType))
return getPredictValue(root.leftTree, instance, isDigit);
return getPredictValue(root.rightTree, instance, isDigit);
}
}
public Tree constructTree(ArrayList<ArrayList<Integer>> leafNodes,ArrayList<Double> leafValues,int K,int splitPoints, Boolean isDigit[],ArrayList<Integer> subIdx,ArrayList<ArrayList<String>> trainData,ArrayList<Double> target,int maxDepth[],int depth)
{
int n=trainData.size();
int dim=trainData.get(0).size();
ArrayList<Integer> leftTreeIdx=new ArrayList<>();
ArrayList<Integer> rightTreeIdx=new ArrayList<>();
if(depth<maxDepth[0])
{
/*
* 从所有的attribute中选取最佳的attribute，并且attribute中最佳的分割点，对数据进行分割
* */
double loss=-1;
ArrayList<Integer> leftNodes=new ArrayList<>();
ArrayList<Integer> rightNodes=new ArrayList<>();
int attributeSplit=0;
String attributeSplitType="";
for(int i=0;i<dim;i++)//遍历所有的attribute
{
//得到该attribute下所有的distinct的值
ArrayList<String> myAttributeSet=new ArrayList<>();
ArrayList<String> subDigitAttribute=new ArrayList<>();
myAttributeSet=getAttributeSet(trainData, i);
if(isDigit[i])//如果是数字，就从数组中随机选取splitpoints个节点，代表这个属性可以在这splitpoints下进行分割
{
while(subDigitAttribute.size()<splitPoints)
{
Random r=new Random();
int tmp=r.nextInt(myAttributeSet.size());
subDigitAttribute.add(myAttributeSet.get(tmp));
myAttributeSet.clear();
myAttributeSet=subDigitAttribute;
}
}
for(int j=0;j<myAttributeSet.size();j++)
{
for(int k=0;k<subIdx.size();k++)
{
if((!isDigit[i]&&trainData.get(subIdx.get(k)).get(i).trim().equals(myAttributeSet.get(j)))||(isDigit[i]&&myCmpLess(trainData.get(subIdx.get(k)).get(i),myAttributeSet.get(j))))
{
leftTreeIdx.add(subIdx.get(k));
}
else
{
rightTreeIdx.add(subIdx.get(k));
}
}
ArrayList<Double> leftTarget=new ArrayList<>();
ArrayList<Double> rightTarget=new ArrayList<>();
for(int k=0;k<leftTreeIdx.size();k++)
leftTarget.add(target.get(leftTreeIdx.get(k)));
for(int k=0;k<rightTreeIdx.size();k++)
rightTarget.add(target.get(rightTreeIdx.get(k)));
double lossTmp=computeLoss(leftTarget)+computeLoss(rightTarget);
if(loss<0||loss<lossTmp)
{
leftNodes.clear();
rightNodes.clear();
for(int k=0;k<leftTreeIdx.size();k++)
leftNodes.add(leftTreeIdx.get(k));
for(int k=0;k<rightTreeIdx.size();k++)
rightNodes.add(rightTreeIdx.get(k));
attributeSplit=i;
attributeSplitType=myAttributeSet.get(j);
}
}
}
Tree tmpTree=new Tree();
tmpTree.attributeSplit=attributeSplit;
tmpTree.attributeSplitType=attributeSplitType;
tmpTree.loss=loss;
tmpTree.isLeaf=false;
tmpTree.leftTree=constructTree(leafNodes,leafValues,K,splitPoints, isDigit, leftNodes, trainData, target, maxDepth, depth+1);
tmpTree.leftTree=constructTree(leafNodes,leafValues,K,splitPoints, isDigit, rightNodes, trainData, target, maxDepth, depth+1);
return tmpTree;
}
else
{
Tree tmpTree=new Tree();
tmpTree.isLeaf=true;
tmpTree.leafValue=getPredictValue(K, subIdx, target);
for(int i=0;i<subIdx.size();i++)
tmpTree.leafNodeSet.add(subIdx.get(i));
leafNodes.add(subIdx);
leafValues.add(tmpTree.leafValue);
return tmpTree;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Tree aTree=new Tree();
}
}
GBDT类
import java.rmi.server.SkeletonNotFoundException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import java.util.Set;
public class GBDT {
private ArrayList<ArrayList<String>> datas=new ArrayList<ArrayList<String>>();
private ArrayList<String> labelSets=new ArrayList<>();
private ArrayList<ArrayList<Double>> F=new ArrayList<ArrayList<Double>>();
private ArrayList<ArrayList<Double>> residual=new ArrayList<ArrayList<Double>>();
private ArrayList<ArrayList<String>> trainData=new ArrayList<ArrayList<String>>();
private ArrayList<Integer> labelTrainData=new ArrayList<Integer>();
private int K;
private Boolean isDigit[];
private int dim;
private int n;
private double learningRate;
private ArrayList<ArrayList<Tree>> trees=new ArrayList<ArrayList<Tree>>(); //存放所有的树
private int max_iter;
private double sampleRate;
private int maxDepth;
private int splitPoints;
public void computeResidual(ArrayList<Integer> subId)
{
for(int i=0;i<subId.size();i++)
{
int idx=subId.get(i);
int y=0;
if(this.labelTrainData.get(idx)==-1) y=0;
else y=1;
double sum=Math.exp(this.F.get(idx).get(0))+Math.exp(this.F.get(idx).get(1));
double p1=Math.exp(this.F.get(idx).get(0))/sum,p2=Math.exp(this.F.get(idx).get(1))/sum;
this.residual.get(idx).set(0, y-p1);
this.residual.get(idx).set(1, y-p2);
}
}
public ArrayList<Integer> myrandom(int maxNum,int num)
{
ArrayList<Integer> ans=new ArrayList<>();
Set<Integer> mySet=new HashSet<>();
while(mySet.size()<num)
{
Random r=new Random();
int tmp=r.nextInt(maxNum);
mySet.add(tmp);
}
Iterator<Integer> it=mySet.iterator();
while(it.hasNext())
{
ans.add(it.next());
}
return ans;
}
public GBDT()
{
this.max_iter=50;
this.sampleRate=0.8;
this.K=2;//2分类问题
this.maxDepth=6;
this.splitPoints=3;
this.learningRate=0.01;
getData();
}
public void train()
{
for(int i=0;i<max_iter;i++)
{
ArrayList<Integer> subSet=new ArrayList<>();
int numSubset=(int)(this.n*this.sampleRate);
subSet=myrandom(this.n,numSubset);
computeResidual(subSet);
ArrayList<Double> target=new ArrayList<>();
ArrayList<Tree> tmpTree=new ArrayList<>();
int maxdepths[]={this.maxDepth};
for(int j=0;j<this.K;j++)
{
target.clear();
for(int k=0;k<subSet.size();k++)
{
target.add(residual.get(subSet.get(k)).get(j));
}
ArrayList<ArrayList<Integer>> leafNodes=new ArrayList<ArrayList<Integer>>();
ArrayList<Double> leafValues=new ArrayList<>();
Tree treeSub=new Tree();
Tree iterTree=treeSub.constructTree(leafNodes,leafValues,K,splitPoints, isDigit, subSet, trainData, target,maxdepths,0);
tmpTree.add(iterTree);
updateFvalue(isDigit, subSet,leafNodes,leafValues,j,iterTree);
}
trees.add(tmpTree);
}
}
public void updateFvalue(Boolean isDigit[], ArrayList<Integer> subIdx,ArrayList<ArrayList<Integer>> leafNodes,ArrayList<Double> leafValues,int label,Tree root)
{
ArrayList<Integer> remainIdx=new ArrayList<>();
int arr[]=new int[this.n];
for(int i=0;i<this.n;i++)
arr[i]=i;
for(int i=0;i<subIdx.size();i++)
{
arr[subIdx.get(i)]=-1;
}
//求出不是用来训练树的余下集合
for(int i=0;i<this.n;i++)
{
if(arr[i]!=-1)
remainIdx.add(i);
}
for(int i=0;i<leafNodes.size();i++)
{
for(int j=0;j<leafNodes.get(i).size();j++)
{
this.F.get(leafNodes.get(i).get(j)).set(label, this.F.get(leafNodes.get(i).get(j)).get(label)+this.learningRate*root.getPredictValue(root));
}
}
for(int i=0;i<remainIdx.size();i++)
{
double leafV=root.getPredictValue(root,this.trainData.get(remainIdx.get(i)),isDigit);
this.F.get(remainIdx.get(i)).set(label, this.F.get(remainIdx.get(i)).get(label)+this.learningRate*leafV);
}
}
public boolean checkDigit(String str) {
for(int i=0;i<str.length();i++)
{
if(!(str.charAt(i)>='0'&&str.charAt(i)<='9'))
{
return false;
}
}
return true;
}
public void getData() {
Data d =new Data();
this.datas=d.getTrainData();
this.dim=this.datas.get(0).size()-1;
this.isDigit=new Boolean[this.dim];
//遍历所有样本，去掉中间含有不是正常的数据
for(int i=0;i<this.datas.get(0).size()-1;i++)
labelSets.add(this.datas.get(0).get(i));
//保证数据的第一行是正确的，来判断，特征哪些纬度是数字，哪些纬度是字符串
for(int i=0;i<this.dim;i++)
{
if(checkDigit(this.datas.get(0).get(i)))
this.isDigit[i]=true;
else this.isDigit[i]=false;
}
//如果字符串==？说明是异常数据，这里做数据的清理
for(int i=1;i<this.datas.size();i++)
{
ArrayList<String> tmp=new ArrayList<>();
boolean flag=true;
for(int j=0;j<this.dim;j++)
{
if(datas.get(i).get(j).trim().equals("?"))
{
flag=false;
break;
}
}
if(!flag) continue;
if(datas.get(i).get(this.dim).trim().equals("?")) continue;
trainData.add(tmp);
if(datas.get(i).get(this.dim).trim().equals("<=50K"))
labelTrainData.add(-1);
else
labelTrainData.add(1);
}
this.n=this.labelTrainData.size();
for(int i=0;i<this.datas.get(0).size()-1;i++)
labelSets.add(this.datas.get(0).get(i));
//初始化F矩阵为全0,F矩阵是n*2，是2分类问题，如果要多分类，改下这里就可以了
for(int i=0;i<this.n;i++)
{
ArrayList<Double> arrTmp=new ArrayList<Double>();
for(int j=0;j<2;j++)
{
arrTmp.add(0.0);
}
this.F.add(arrTmp);
this.residual.add(arrTmp);
}
}
public static void main(String[] args) {
GBDT dGbdt=new GBDT();
dGbdt.getData();
System.err.println(dGbdt.n);
}
}