工厂模式+单例模式封装WekaFactory来构造Weka中各种对象

chenwq

更方便更简单起见，封装了Weka。虽然我不懂Weka


// 测试WekaFactory

1. 
   
2. package cn.edu.xmu.bdm.wekainjava.utils;
   
3. 
   
4. import java.io.File;
   
5. 
   
6. import weka.classifiers.Classifier;
   
7. import weka.classifiers.Evaluation;
   
8. import weka.classifiers.trees.J48;
   
9. import weka.core.Instances;
   
10. 
    
11. public class TestWekaFactory {
    
12. 
    
13.         /**
    
14.          * @param args
    
15.          * @throws Exception
    
16.          */
    
17.         public static void main(String[] args) throws Exception {
    
18.                 File trainFile = new File(
    
19.                                 "C:\\Program Files\\Weka-3-6\\data\\cpu.with.vendor.arff");
    
20.                 File testFile = new File(
    
21.                                 "C:\\Program Files\\Weka-3-6\\data\\cpu.with.vendor.arff");
    
22.                 /**
    
23.                  * 1. 获取weka工厂类
    
24.                  */
    
25.                 WekaFactory wi = WekaFactoryImpl.getInstance();
    
26.                 /**
    
27.                  * 2. 从工厂中获取分类器 具体使用哪一种特定的分类器可以选择 这样就构建了一个简单的分类器
    
28.                  */
    
29.                 Classifier j48 = (Classifier) wi.getClassifier(J48.class);
    
30. 
    
31.                 /**
    
32.                  * 3. 从工厂中获取训练样本和测试样本实例
    
33.                  */
    
34.                 Instances instancesTrain = wi.getInstance(trainFile);
    
35.                 instancesTrain.setClassIndex(0);
    
36. 
    
37.                 Instances instancesTest = wi.getInstance(testFile);
    
38.                 instancesTest.setClassIndex(0);
    
39. 
    
40.                 /**
    
41.                  * 4.使用训练样本训练分类器
    
42.                  */
    
43.                 j48.buildClassifier(instancesTrain);
    
44. 
    
45.                 /**
    
46.                  * 5. 从工厂中获取使用Evaluation，测试样本测试分类器的学习效果
    
47.                  */
    
48.                 double sum = instancesTrain.numInstances();
    
49.                 Evaluation testingEvaluation = wi.getEvaluation(j48, instancesTrain);
    
50.                 int length = instancesTest.numInstances();
    
51.                 for (int i = 0; i < length; i++) {
    
52.                         // 通过这个方法来用每个测试样本测试分类器的效果
    
53.                         testingEvaluation.evaluateModelOnceAndRecordPrediction(j48,
    
54.                                         instancesTest.instance(i));
    
55.                 }
    
56.                                 System.out.println(testingEvaluation.toSummaryString());
    
57.                 System.out.println("分类器的正确率：" + (1 - testingEvaluation.errorRate()));
    
58.         }
    
59. 
    
60. }
    

复制代码

工厂模式封装的优点：
    1. 良好的封装性，代码结构清晰
    2. 扩展性很好
    3. 屏蔽weka具体类
    4. 典型的解耦框架

单例模式的优点：
　  1. 减少内存开支
    2. 减少系统性能开销
    3. 避免对资源的多重占用
    4. 可以在系统设置全局访问点，优化和共享资源访问

单例的创建使用双重检查加锁方式，延迟加载以及线程安全

1. 
   
2. package cn.edu.xmu.bdm.wekainjava.utils;
   
3. 
   
4. import java.io.File;
   
5. 
   
6. import weka.classifiers.Classifier;
   
7. import weka.classifiers.Evaluation;
   
8. import weka.core.Instances;
   
9. 
   
10. /**
    
11. * desc:weka各种类工厂
    
12. * <code>WekaFactory</code>
    
13. * @version 1.0
    
14. * @author chenwq
    
15. *
    
16. */
    
17. public abstract  class WekaFactory {
    
18.         /**
    
19.          * java.lang.Object
    
20.            *                 ——weka.core.Instances
    
21.          * @param clazz
    
22.          * @return
    
23.          */
    
24.         public abstract <T extends Classifier> T getClassifier(Class<T> clazz);
    
25.        
    
26.         /**
    
27.          * 从.arff文件中获取样本Instances;
    
28.          * @param fileName 获得instances的文件名
    
29.          * @return
    
30.          */
    
31.         public abstract <T extends Instances> T getInstance(String fileName);
    
32.         /**
    
33.          * 从.arff文件中获取样本Instances;
    
34.          * @param file 获得instances的File对象
    
35.          * @return
    
36.          */
    
37.         public abstract <T extends Instances> T getInstance(File file);
    
38.        
    
39.         /**
    
40.          * 获得一个Evaluation对象
    
41.          * @param h 一个已经训练过的分类器
    
42.          * @param ins  测试样本
    
43.          * @return
    
44.          */
    
45.         public abstract <T extends Evaluation> T getEvaluation(Classifier h, Instances ins);
    
46. }
    

复制代码

1. package cn.edu.xmu.bdm.wekainjava.utils;
   
2. 
   
3. import java.io.File;
   
4. 
   
5. import weka.classifiers.Classifier;
   
6. import weka.classifiers.Evaluation;
   
7. import weka.core.Instance;
   
8. import weka.core.Instances;
   
9. import weka.core.converters.ArffLoader;
   
10. 
    
11. /**
    
12. *@see cn.edu.xmu.bdm.wekainjava.utils.WekaFactory
    
13. */
    
14. public class WekaFactoryImpl extends WekaFactory{
    
15.         private volatile static WekaFactoryImpl instance = null;
    
16. 
    
17.         private WekaFactoryImpl() {
    
18.         }
    
19. 
    
20.         public synchronized static WekaFactoryImpl getInstance() {
    
21.                 if (instance == null) {
    
22.                         instance = new WekaFactoryImpl();
    
23.                 }
    
24.                 return instance;
    
25.         }
    
26.        
    
27.         @Override
    
28.         /**
    
29.          * @
    
30.          */
    
31.         public <T extends Classifier> T getClassifier(Class<T> clazz) {
    
32.                 Classifier classifier  = null;
    
33.                 try{
    
34.                         classifier = (Classifier)Class.forName(clazz.getName()).newInstance();
    
35.                 }catch(Exception e){
    
36.                         //TODO:创建Classifier异常处理
    
37.                 }
    
38.                 return (T)classifier;
    
39.         }
    
40. 
    
41.         @Override
    
42.         public <T extends Instances> T getInstance(String fileName) {
    
43.                 File file = new File(fileName);
    
44.                 return getInstance(file);
    
45.         }
    
46. 
    
47.         @Override
    
48.         public <T extends Instances> T getInstance(File file) {
    
49.                 Instances inst = null;
    
50.                 try {
    
51.                         ArffLoader loader = new ArffLoader();
    
52.                         loader.setFile(file);
    
53.                         inst = loader.getDataSet();
    
54.                 } catch (Exception e) {
    
55.                         //TODO:创建Instances异常处理
    
56.                 }
    
57.                 return (T)inst;
    
58.         }
    
59. 
    
60.         @Override
    
61.         public <T extends Evaluation> T getEvaluation(Classifier h, Instances ins) {
    
62.                 try {
    
63.                         Instance testInst;
    
64.                         /*
    
65.                          * Evaluation: Class for evaluating machine learning models
    
66.                          * 即它是用于检测分类模型的类
    
67.                          */
    
68.                         Evaluation testingEvaluation = new Evaluation(ins);
    
69.                         int length = ins.numInstances();
    
70.                         for (int i = 0; i < length; i++) {
    
71.                                 testInst = ins.instance(i);
    
72.                                 // 通过这个方法来用每个测试样本测试分类器的效果
    
73.                                 testingEvaluation.evaluateModelOnceAndRecordPrediction(h,
    
74.                                                 testInst);
    
75.                         }
    
76.                         return (T)testingEvaluation;
    
77.                 } catch (Exception e) {
    
78.                         System.out.println("haha bug!");
    
79.                         System.out.println(e);
    
80.                 }
    
81.                 return null;
    
82.         }
    
83. }
    

复制代码

xmubingo

学习了！

zouquan

真是太棒了，chenwq下学期能不能做个报告，给大家讲讲工厂模式、封装与抽象。

我们的java基本都是自学，没系统的讲过课，好多东西都不懂。

tangzk

貌似找到个小错误。
TestWekaFactory.java类中的Line48：
Evaluation testingEvaluation = wi.getEvaluation(j48, instancesTest);
应该是：
Evaluation testingEvaluation = wi.getEvaluation(j48, instancesTrain);   // 使用训练集训练模型
吧？

chenwq

tangzk 发表于 2012-2-19 09:52
貌似找到个小错误。
TestWekaFactory.java类中的Line48：
Evaluation testingEvaluation = wi.getEvaluat ...

已修改。
感谢@tangzk 纠错！

cwc

支持强哥做报告！

chenwq

Category Pattern http://c2.com/cgi/wiki?CategoryPattern

RockRabbit

学习了+1