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

chenwq · 发表于 2012-1-17 21:30:40

本帖最后由 chenwq 于 2012-2-20 10:52 编辑

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

// 测试WekaFactory

package cn.edu.xmu.bdm.wekainjava.utils;
import java.io.File;
import weka.classifiers.Classifier;
import weka.classifiers.Evaluation;
import weka.classifiers.trees.J48;
import weka.core.Instances;
public class TestWekaFactory {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
File trainFile = new File(
"C:\\Program Files\\Weka-3-6\\data\\cpu.with.vendor.arff");
File testFile = new File(
"C:\\Program Files\\Weka-3-6\\data\\cpu.with.vendor.arff");
/**
* 1. 获取weka工厂类
*/
WekaFactory wi = WekaFactoryImpl.getInstance();
/**
* 2. 从工厂中获取分类器具体使用哪一种特定的分类器可以选择这样就构建了一个简单的分类器
*/
Classifier j48 = (Classifier) wi.getClassifier(J48.class);
/**
* 3. 从工厂中获取训练样本和测试样本实例
*/
Instances instancesTrain = wi.getInstance(trainFile);
instancesTrain.setClassIndex(0);
Instances instancesTest = wi.getInstance(testFile);
instancesTest.setClassIndex(0);
/**
* 4.使用训练样本训练分类器
*/
j48.buildClassifier(instancesTrain);
/**
* 5. 从工厂中获取使用Evaluation，测试样本测试分类器的学习效果
*/
double sum = instancesTrain.numInstances();
Evaluation testingEvaluation = wi.getEvaluation(j48, instancesTrain);
int length = instancesTest.numInstances();
for (int i = 0; i < length; i++) {
// 通过这个方法来用每个测试样本测试分类器的效果
testingEvaluation.evaluateModelOnceAndRecordPrediction(j48,
instancesTest.instance(i));
}
System.out.println(testingEvaluation.toSummaryString());
System.out.println("分类器的正确率：" + (1 - testingEvaluation.errorRate()));
}
}

复制代码

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

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

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

package cn.edu.xmu.bdm.wekainjava.utils;
import java.io.File;
import weka.classifiers.Classifier;
import weka.classifiers.Evaluation;
import weka.core.Instances;
/**
* desc:weka各种类工厂
* <code>WekaFactory</code>
* @version 1.0
* @author chenwq
*
*/
public abstract class WekaFactory {
/**
* java.lang.Object
* ——weka.core.Instances
* @param clazz
* @return
*/
public abstract <T extends Classifier> T getClassifier(Class<T> clazz);
/**
* 从.arff文件中获取样本Instances;
* @param fileName 获得instances的文件名
* @return
*/
public abstract <T extends Instances> T getInstance(String fileName);
/**
* 从.arff文件中获取样本Instances;
* @param file 获得instances的File对象
* @return
*/
public abstract <T extends Instances> T getInstance(File file);
/**
* 获得一个Evaluation对象
* @param h 一个已经训练过的分类器
* @param ins 测试样本
* @return
*/
public abstract <T extends Evaluation> T getEvaluation(Classifier h, Instances ins);
}

复制代码

package cn.edu.xmu.bdm.wekainjava.utils;
import java.io.File;
import weka.classifiers.Classifier;
import weka.classifiers.Evaluation;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.converters.ArffLoader;
/**
*@see cn.edu.xmu.bdm.wekainjava.utils.WekaFactory
*/
public class WekaFactoryImpl extends WekaFactory{
private volatile static WekaFactoryImpl instance = null;
private WekaFactoryImpl() {
}
public synchronized static WekaFactoryImpl getInstance() {
if (instance == null) {
instance = new WekaFactoryImpl();
}
return instance;
}
@Override
/**
* @
*/
public <T extends Classifier> T getClassifier(Class<T> clazz) {
Classifier classifier = null;
try{
classifier = (Classifier)Class.forName(clazz.getName()).newInstance();
}catch(Exception e){
//TODO:创建Classifier异常处理
}
return (T)classifier;
}
@Override
public <T extends Instances> T getInstance(String fileName) {
File file = new File(fileName);
return getInstance(file);
}
@Override
public <T extends Instances> T getInstance(File file) {
Instances inst = null;
try {
ArffLoader loader = new ArffLoader();
loader.setFile(file);
inst = loader.getDataSet();
} catch (Exception e) {
//TODO:创建Instances异常处理
}
return (T)inst;
}
@Override
public <T extends Evaluation> T getEvaluation(Classifier h, Instances ins) {
try {
Instance testInst;
/*
* Evaluation: Class for evaluating machine learning models
* 即它是用于检测分类模型的类
*/
Evaluation testingEvaluation = new Evaluation(ins);
int length = ins.numInstances();
for (int i = 0; i < length; i++) {
testInst = ins.instance(i);
// 通过这个方法来用每个测试样本测试分类器的效果
testingEvaluation.evaluateModelOnceAndRecordPrediction(h,
testInst);
}
return (T)testingEvaluation;
} catch (Exception e) {
System.out.println("haha bug!");
System.out.println(e);
}
return null;
}
}

复制代码

xmubingo · 发表于 2012-1-18 08:39:27

学习了！

zouquan · 发表于 2012-1-18 23:57:25

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

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

tangzk · 发表于 2012-2-19 09:52:39

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

chenwq · 发表于 2012-2-20 10:53:03

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

已修改。
感谢@tangzk 纠错！

cwc · 发表于 2012-2-20 16:12:10

支持强哥做报告！

chenwq · 发表于 2012-2-27 10:38:08

本帖最后由 chenwq 于 2012-2-27 10:38 编辑

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

RockRabbit · 发表于 2012-2-27 20:13:53

学习了+1

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

浏览过的版块