[Java] 数据分析--分类

ID3算法

• 思路：分类算法的输入为训练集，输出为对数据进行分类的函数。ID3算法为分类函数生成分类树
• 需求：对水果训练集的一个维度（是否甜）进行预测
• 实现：决策树，熵函数，ID3，weka库 J48类

ComputeGain.java

public class ComputeGain {
    public static void main(String[] args) {
        System.out.printf("h(11,16) = %.4f%n", h(11,16));
        System.out.println("Gain(Size):");
        System.out.printf("	h(3,5) = %.4f%n", h(3,5));
        System.out.printf("	h(6,7) = %.4f%n", h(6,7));
        System.out.printf("	h(2,4) = %.4f%n", h(2,4));
        System.out.printf("	g({3,6,2},{5,7,4}) = %.4f%n", 
                    g(new int[]{3,6,2},new int[]{5,7,4}));
        System.out.println("Gain(Color):");
        System.out.printf("	h(3,4) = %.4f%n", h(3,4));
        System.out.printf("	h(3,5) = %.4f%n", h(3,5));
        System.out.printf("	h(2,3) = %.4f%n", h(2,3));
        System.out.printf("	h(2,4) = %.4f%n", h(2,4));
        System.out.printf("	g({3,3,2,2},{4,5,3,4}) = %.4f%n", 
                    g(new int[]{3,3,2,2},new int[]{4,5,3,4}));
        System.out.println("Gain(Surface):");
        System.out.printf("	h(4,7) = %.4f%n", h(4,7));
        System.out.printf("	h(4,6) = %.4f%n", h(4,6));
        System.out.printf("	h(3,3) = %.4f%n", h(3,3));
        System.out.printf("	g({4,4,3},{7,6,3}) = %.4f%n", 
                    g(new int[]{4,4,3},new int[]{7,6,3}));
        System.out.println("Gain(Size|SMOOTH):");
        System.out.printf("	h(1,3) = %.4f%n", h(1,3));
        System.out.printf("	h(3,3) = %.4f%n", h(3,3));
        System.out.printf("	g({1,3,0},{3,3,1}) = %.4f%n", 
                    g(new int[]{1,3,0},new int[]{3,3,1}));
        System.out.println("Gain(Color|SMOOTH):");
        System.out.printf("	h(2,3) = %.4f%n", h(2,3));
        System.out.printf("	g({2,2,0},{3,2,2}) = %.4f%n", 
                    g(new int[]{2,2,0},new int[]{3,2,2}));
        System.out.println("Gain(Size|ROUGH):");
        System.out.printf("	h(3,6) = %.4f%n", h(3,6));
        System.out.printf("	h(1,2) = %.4f%n", h(1,2));
        System.out.printf("	g({2,1,1},{2,2,2}) = %.4f%n", 
                    g(new int[]{2,1,1},new int[]{2,2,2}));
        System.out.println("Gain(Color|ROUGH):");
        System.out.printf("	h(4,6) = %.4f%n", h(4,6));
        System.out.printf("	g({1,1,1},{2,2,2}) = %.4f%n", 
                    g(new int[]{1,0,2,1},new int[]{1,2,2,1}));
    }
    
    /*  Gain for the splitting {A1, A2, ...}, where Ai 
        has n[i] points, m[i] of which are favorable.
    */
    public static double g(int[] m, int[] n) {
        int sm = 0, sn = 0;
        double nsh = 0.0;
        for (int i = 0; i < m.length; i++) {
            sm += m[i];
            sn += n[i];
            nsh += n[i]*h(m[i],n[i]);
        }
        return h(sm, sn) - nsh/sn;
    }
    
    /*  Entropy for m favorable items out of n.
    */
    public static double h(int m, int n) {
        if (m == 0 || m == n) {
            return 0;
        }
        double p = (double)m/n, q = 1 - p;
        return -p*lg(p) - q*lg(q);
    }
    
    /*  Returns the binary logarithm of x.
    */
    public static double lg(double x) {
        return Math.log(x)/Math.log(2);
    }
}

h(11,16) = 0.8960
Gain(Size):
h(3,5) = 0.9710
h(6,7) = 0.5917
h(2,4) = 1.0000
g({3,6,2},{5,7,4}) = 0.0838
Gain(Color):
h(3,4) = 0.8113
h(3,5) = 0.9710
h(2,3) = 0.9183
h(2,4) = 1.0000
g({3,3,2,2},{4,5,3,4}) = 0.0260
Gain(Surface):
h(4,7) = 0.9852
h(4,6) = 0.9183
h(3,3) = 0.0000
g({4,4,3},{7,6,3}) = 0.1206
Gain(Size|SMOOTH):
h(1,3) = 0.9183
h(3,3) = 0.0000
g({1,3,0},{3,3,1}) = 0.5917
Gain(Color|SMOOTH):
h(2,3) = 0.9183
g({2,2,0},{3,2,2}) = 0.5917
Gain(Size|ROUGH):
h(3,6) = 1.0000
h(1,2) = 1.0000
g({2,1,1},{2,2,2}) = 0.2516
Gain(Color|ROUGH):
h(4,6) = 0.9183
g({1,1,1},{2,2,2}) = 0.9183

import weka.classifiers.trees.J48;
import weka.core.Instances;
import weka.core.Instance;
import weka.core.converters.ConverterUtils.DataSource;

public class TestWekaJ48 {
    public static void main(String[] args) throws Exception {
        DataSource source = new DataSource("data/AnonFruit.arff");
        Instances instances = source.getDataSet();
        instances.setClassIndex(3);  // target attribute: (Sweet)
        
        J48 j48 = new J48();  // an extension of ID3
        j48.setOptions(new String[]{"-U"});  // use unpruned tree
        j48.buildClassifier(instances);

        for (Instance instance : instances) {
            double prediction = j48.classifyInstance(instance);
            System.out.printf("%4.0f%4.0f%n", 
                    instance.classValue(), prediction);
        }
    }
}

1 1
1 1
1 1
1 0
1 1
0 0
1 1
0 0
0 0
0 0
1 1
1 1
1 1
1 1
0 0
1 1

贝叶斯分类

• 思路：基于训练集计算的比率生成的函数进行分类

Fruit.java

import java.io.File;
import java.io.FileNotFoundException;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Fruit {
    String name, size, color, surface;
    boolean sweet;

    public Fruit(String name, String size, String color, String surface, 
            boolean sweet) {
        this.name = name;
        this.size = size;
        this.color = color;
        this.surface = surface;
        this.sweet = sweet;
    }

    @Override
    public String toString() {
        return String.format("%-12s%-8s%-8s%-8s%s", 
                name, size, color, surface, (sweet? "T": "F") );
    }
    
    public static Set<Fruit> loadData(File file) {
        Set<Fruit> fruits = new HashSet();
        try {
            Scanner input = new Scanner(file);
            for (int i = 0; i < 7; i++) {  // read past metadata
                input.nextLine();
            }
            while (input.hasNextLine()) {
                String line = input.nextLine();
                Scanner lineScanner = new Scanner(line);
                String name = lineScanner.next();
                String size = lineScanner.next();
                String color = lineScanner.next();
                String surface = lineScanner.next();
                boolean sweet = (lineScanner.next().equals("T"));
                Fruit fruit = new Fruit(name, size, color, surface, sweet);
                fruits.add(fruit);
            }
        } catch (FileNotFoundException e) {
            System.err.println(e);
        }
        return fruits;
    }

    public static void print(Set<Fruit> fruits) {
        int k=1;
        for (Fruit fruit : fruits) {
            System.out.printf("%2d. %s%n", k++, fruit);
        }
    }
}

BayesianTest.java

import java.io.File;
import java.util.Set;

public class BayesianTest {
    private static Set<Fruit> fruits;
    
    public static void main(String[] args) {
        fruits = Fruit.loadData(new File("data/Fruit.arff"));
        Fruit fruit = new Fruit("cola", "SMALL", "RED", "SMOOTH", false);
        double n = fruits.size();  // total number of fruits in training set
        double sum1 = 0;           // number of sweet fruits
        for (Fruit f : fruits) {
            sum1 += (f.sweet? 1: 0);
        }
        double sum2 = n - sum1;    // number of sour fruits
        double[][] p = new double[4][3];
        for (Fruit f : fruits) {
            if (f.sweet) {
                p[1][1] += (f.size.equals(fruit.size)? 1: 0)/sum1;
                p[2][1] += (f.color.equals(fruit.color)? 1: 0)/sum1;
                p[3][1] += (f.surface.equals(fruit.surface)? 1: 0)/sum1;
            } else {
                p[1][2] += (f.size.equals(fruit.size)? 1: 0)/sum2;
                p[2][2] += (f.color.equals(fruit.color)? 1: 0)/sum2;
                p[3][2] += (f.surface.equals(fruit.surface)? 1: 0)/sum2;
            }
        }
        double pc1 = p[1][1]*p[2][1]*p[3][1]*sum1/n;
        double pc2 = p[1][2]*p[2][2]*p[3][2]*sum2/n;
        System.out.printf("pc1 = %.4f, pc2 = %.4f%n", pc1, pc2);
        System.out.printf("Predict %s is %s.%n", 
                fruit.name, (pc1 > pc2? "sweet": "sour"));
    }
}

pc1 = 0.0186, pc2 = 0.0150
Predict cola is sweet.

TestWekaBayes.java

import java.util.List;
import weka.classifiers.Evaluation;
import weka.classifiers.bayes.NaiveBayes;
import weka.classifiers.evaluation.Prediction;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.converters.ConverterUtils;
import weka.core.converters.ConverterUtils.DataSource;

public class TestWekaBayes {
    public static void main(String[] args) throws Exception {
//        ConverterUtils.DataSource source = new ConverterUtils.DataSource("data/AnonFruit.arff");
        DataSource source = new DataSource("data/AnonFruit.arff");
        Instances train = source.getDataSet();
        train.setClassIndex(3);  // target attribute: (Sweet)
        //build model
        NaiveBayes model=new NaiveBayes();
        model.buildClassifier(train);

        //use
        Instances test = train;
        Evaluation eval = new Evaluation(test);
        eval.evaluateModel(model,test);
        List <Prediction> predictions = eval.predictions();
        int k = 0;
        for (Instance instance : test) {
            double actual = instance.classValue();
            double prediction = eval.evaluateModelOnce(model, instance);
            System.out.printf("%2d.%4.0f%4.0f", ++k, actual, prediction);
            System.out.println(prediction != actual? " *": "");
        }
    }
}

1. 1 1
2. 1 1
3. 1 1
4. 1 1
5. 1 1
6. 0 1 *
7. 1 1
8. 0 0
9. 0 0
10. 0 1 *
11. 1 1
12. 1 1
13. 1 1
14. 1 1
15. 0 0
16. 1 1

SVM算法

• 思路：生成超平面方程，计算数据点位于哪一边

逻辑回归

• 思路：将目标值属性为布尔值的问题转化成一个数值变量，在转化后的问题上进行线性回归
• 需求：某政党候选人想知道选举获胜的花费
• 实现

import org.apache.commons.math3.analysis.function.*;
import org.apache.commons.math3.stat.regression.SimpleRegression;

public class LogisticRegression {
    static int n = 6;
    static double[] x = {5, 15, 25, 35, 45, 55};
    static double[] p = {2./6,2./5, 4./8, 5./9, 3./5, 4./5};
    static double[] y = new double[n];    // y = logit(p)

    public static void main(String[] args) {
        
        //  Transform p-values into y-values:
        Logit logit = new Logit();
        for (int i = 0; i < n; i++) {
            y[i] = logit.value(p[i]);
        }
        
        //  Set up input array for linear regression:
        double[][] data = new double[n][n];
        for (int i = 0; i < n; i++) {
            data[i][0] = x[i];
            data[i][1] = y[i];
        }
        
        //  Run linear regression of y on x:
        SimpleRegression sr = new SimpleRegression();
        sr.addData(data);
        
        //  Print results:
        for (int i = 0; i < n; i++) {
            System.out.printf("x = %2.0f, y = %7.4f%n", x[i], sr.predict(x[i]));
        }
        System.out.println();
        
        //  Convert y-values back to p-values:
        Sigmoid sigmoid = new Sigmoid();
        for (int i = 0; i < n; i++) {
            double p = sr.predict(x[i]);
            System.out.printf("x = %2.0f, p = %6.4f%n", x[i], sigmoid.value(p));
        }
    }
}

x = 5, y = -0.7797
x = 15, y = -0.4067
x = 25, y = -0.0338
x = 35, y = 0.3392
x = 45, y = 0.7121
x = 55, y = 1.0851

x = 5, p = 0.3144
x = 15, p = 0.3997
x = 25, p = 0.4916
x = 35, p = 0.5840
x = 45, p = 0.6709
x = 55, p = 0.7475

k临近

• 思路：根据临近范围内的样本进行分类

import weka.classifiers.lazy.IBk;  // K-Nearest Neighbors
import weka.core.Instances;
import weka.core.Instance;
import weka.core.converters.ConverterUtils.DataSource;

public class TestIBk {
    public static void main(String[] args) throws Exception {
        DataSource source = new DataSource("data/AnonFruit.arff");
        Instances instances = source.getDataSet();
        instances.setClassIndex(3);  // target attribute: (Sweet)
        
        IBk ibk = new IBk();
        ibk.buildClassifier(instances);

        for (Instance instance : instances) {
            double prediction = ibk.classifyInstance(instance);
            System.out.printf("%4.0f%4.0f%n", 
                    instance.classValue(), prediction);
        }
    }
}

1 1
1 1
1 1
1 0
1 1
0 0
1 1
0 0
0 0
0 0
1 1
1 1
1 1
1 1
0 0
1 1