首页 技术 正文
技术 2022年11月23日
0 收藏 746 点赞 3,161 浏览 13187 个字

一、什么是arff格式文件

  1、arff是Attribute-Relation File Format缩写,从英文字面也能大概看出什么意思。它是weka数据挖掘开源程序使用的一种文件模式。由于weka是个很出色的数据挖掘开源项目,所以使用的比较广,这也无形中推广了它的数据存储格式。

  2、下面是weka自带的一个arff文件例子(weather.arff)

 @relation weather @attribute outlook {sunny, overcast, rainy}
@attribute temperature real
@attribute humidity real
@attribute windy {TRUE, FALSE}
@attribute play {yes, no} @data
sunny,,,FALSE,no
sunny,,,TRUE,no
overcast,,,FALSE,yes
rainy,,,FALSE,yes
rainy,,,FALSE,yes
rainy,,,TRUE,no
overcast,,,TRUE,yes
sunny,,,FALSE,no
sunny,,,FALSE,yes
rainy,,,FALSE,yes
sunny,,,TRUE,yes
overcast,,,TRUE,yes
overcast,,,FALSE,yes
rainy,,,TRUE,no

  a) 第1行,是关系名称,这个自己随便起,不过写的最好要有意义。

   b) 第3~7行是特征列表,其中第1列是特征说明,不可缺少,第2列是特征名称,第3列是特征类型或特征取值范围。

   c) @data(第9行)是数据域说明,在它下面的全是数据。其中每一行体表一条数据。

   d) 例子中给出的数据域是最基本的表示方法,实际应用中,一般都是用稀疏表示法。

   e) 此处对于arff文件格式不做进一步解释,不懂的地方可以给我留言。

二、总体思路

  1、生成特征文件

  2、文件格式转换

三、具体实现

  1、特征的生成

    这里假设我们已经生成了特征。(因为特征选择我会另写一篇文章单独介绍)

  2、arff文件生成

    a) 生成文件的接口

 package com.lvxinjian.alg.models.generatefile; /**
* @Descriptin : 生成指定格式文件的接口
* @author :Lv Xinjian
*
*/
public interface GenerateFile {
/**
* @function 生成文件
* @param obj 输入数据
* @param option 参数
* @return 是否生成成功
*/
abstract public boolean GenerFile(Object obj , String option);
}

     b) 生成arff的主文件

 package com.lvxinjian.alg.models.generatefile; import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future; import weka.core.FastVector;
import weka.core.Instance;
import weka.core.Instances; import com.iminer.alg.models.sampling.SVMSampleBean;
import com.iminer.alg.models.sampling.SampleBean;
import com.iminer.alg.models.sampling.SampleUtils;
import com.iminer.tool.common.util.FileTool; /**
* @Description : 生成arff格式的文件
* @author : Lv Xinjian
*
*/
public class GenerateArffFile implements GenerateFile { /**
* 保存arff文件
*/
private static Instances data = null;
/**
* 分类标签
*/
private ClassifyAttribute classifyAttribute = new ClassifyAttribute();
/**
* Instance name
*/
public final String InstanceName = "MyRelation";
/**
* 抽取instance的方法 ,默认为方法一
*/
private String getInstancesMothed = "one";
/**
* 保存转换后的SVM数据
*/
private ArrayList<SVMSampleBean> listSVMBean = new ArrayList<SVMSampleBean>();
/**
* 生成arff文件时使用的词表路径
*/
private String lexPath = null;
/**
* 保存arff文件的路径
*/
private String outputPath = null;
/**
* 生成arff文件的主函数
*/
private int threadNum = 5;
@Override
public boolean GenerFile(Object obj, String option) {
String [] paramArray = option.split(" ");
return GenerFile(obj,paramArray);
}
/**
* 生成arff文件的主函数
*/
public boolean GenerFile(Object obj, String [] paramArray) {
try {
if(!Initialization(obj , paramArray))
return false;
GenerateData();
} catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
/**
* @function 解析命令行,初始化参数
* @param obj 传入的数据
* @param paramArrayOfString 命令行
* @return 初始化是否生成成功,true:成功 false:失败
*/
private boolean Initialization(Object obj, String [] paramArrayOfString){
try{
ArrayList<?> list = (ArrayList<?>)obj;
for(Object s : list){
listSVMBean.add((SVMSampleBean)s);
}
//初始化词表路径
String lexPath = ParameterUtils.getOption("lexPath", paramArrayOfString);
if(lexPath.length() != 0)
this.lexPath = lexPath;
//初始化arff文件保存路径
String outputPath = ParameterUtils.getOption("output", paramArrayOfString);
if(outputPath.length() != 0)
this.outputPath = outputPath;
//初始化instance抽取方法,默认为方法一
String getInstanceMothed = ParameterUtils.getOption("mothed", paramArrayOfString);
if(getInstanceMothed.length() != 0)
this.getInstancesMothed = getInstanceMothed;
String threadNum = ParameterUtils.getOption("thread", paramArrayOfString);
if(threadNum.length() != 0){
this.threadNum = Integer.parseInt(threadNum);
System.out.println("线程数 :" + this.threadNum);
}else{
System.out.println("使用默认线程数:5");
}
//初始化类别名称,不可省略
String className = ParameterUtils.getOption("class", paramArrayOfString);
if(className.length() != 0)
classifyAttribute.setClassname(className);
//初始化类别标签
String labels = ParameterUtils.getOption("label", paramArrayOfString);
if(labels.length() != 0){
classifyAttribute.setClassLabel(labels.split(","));
}
else{
System.out.println("please Initialize classify labels!");
return false;
}
}
catch(Exception e){
e.printStackTrace();
} return true;
}
/**
* @function 生成arff的主函数
* @throws IOException
*/
public void GenerateData() throws IOException {
ArrayList<String> words = new ArrayList<String>();
FastVector atts = ArffFileUtils.GetAttributes(this.lexPath , words ,this.classifyAttribute ); data = new Instances(this.InstanceName, atts, 0); ExecutorService service = Executors.newFixedThreadPool(this.threadNum);
int count = 0;
for (SVMSampleBean it : listSVMBean) {
if (count++ % 1000 == 0)
System.out.println("processed " + count + " recoreds"); //获取类别标签的下标
double labelVal = data.attribute(classifyAttribute.getClassname()).indexOfValue(it.getLabel()); MyCallableClass task = new MyCallableClass(labelVal, it.getContent(), words ,this.getInstancesMothed);
Future is = service.submit(task);
try{
if(is.get() != null)
data.add((Instance) is.get());
}catch(Exception e){
e.printStackTrace();
}
}
service.shutdown();
//保存data中的数据
ArffFileUtils.savaInstances(data,this.outputPath);
//清空data中的数据
data.delete();
}
/**
* @function
* @param lstContent
* @param lexPath
* @param labels
* @param outputPath
* @return
*/
public static boolean generateArff(ArrayList<String> lstContent ,String lexPath , String labels, String outputPath){
try{
ArrayList<SampleBean> list = new ArrayList<SampleBean>();
HashSet<String> lstLabel = new HashSet<String>();
for(String str : lstContent){
SVMSampleBean svmBean = new SVMSampleBean(str.replace("\t", SampleUtils.SPECIAL_CHAR));
list.add(svmBean);
lstLabel.add(svmBean.label);
}
if(labels == null){
labels = "";
for(String label : lstLabel){
if(labels != "")
labels += ",";
labels += label;
}
}
String [] options = new String[]{"-lexPath" , lexPath,
"-output" , outputPath,
"-mothed" , "one",
"-class" , "CLASS",
"-label" , labels};
GenerateArffFile genArff =new GenerateArffFile();
genArff.GenerFile(list, options);
return true;
}catch(Exception e){
e.printStackTrace();
return false;
} }
public static void main(String [] args){
try{
String root = "C:\\Users\\Administrator\\Desktop\\12_05\\模型训练\\1219\\";
ArrayList<SampleBean> list = new ArrayList<SampleBean>();
ArrayList<String> lstContent = FileTool.LoadListFromFile(root + "不重合的部分.23.txt", 0 , Charset.forName("utf8"));
for(String str : lstContent){ SVMSampleBean svmBean = new SVMSampleBean(str.replace("\t", SampleUtils.SPECIAL_CHAR));
list.add(svmBean);
}
// DFFeatureSelector selector = new DFFeatureSelector();
// String options = "-maxFeatureNum 1000 -outputPath "+root + "lex.txt";
// selector.selectFeature(list, options); // options = "-lexPath "+root +"lex.txt -output genArffTest.arff -mothed one -class CLASS -label -1,1,2"; String [] options = new String[]{"-lexPath" , root + "temp/temp.lex",
"-output" , root + "不重合的部分.23.arff",
"-mothed" , "one",
"-class" , "CLASS",
"-label" , "2,1,-1",
"-thread","10"};
GenerateArffFile genArff =new GenerateArffFile();
genArff.GenerFile(list, options);
CalcAttributeFromArffFile.calcAttribute(root + "不重合的部分.23.arff" , root + "calc.txt");
}catch(Exception e){
e.printStackTrace();
} }
}

    c) 命令行解析工具

 package com.lvxinjian.alg.models.generatefile; /**
* @Description : 抽取参数
* @author : Lv Xinjian
*/
public class ParameterUtils { static public void main(String [] args){
String option = "-min 1 -max 100 -w 1.2,1.3 -filter g";
try {
boolean r = getFlag("filter", option.split(" "));
System.out.println(r); } catch (Exception e) {
e.printStackTrace();
}
}
/**
* @function 抽取字符类的布尔型参数
* @param flag 字符
* @param options 参数数组
* @return
* @throws Exception
*/
public static boolean getFlag(char flag, String[] options) throws Exception
{
return getFlag("" + flag, options);
}
/**
* @function 抽取字符串类的布尔型参数
* @param flag 字符
* @param options 参数数组
* @return
* @throws Exception
*/
public static boolean getFlag(String flag, String[] options) throws Exception
{
int pos = getOptionPos(flag, options); if (pos > -1) {
options[pos] = "";
}
return (pos > -1);
}
/**
* @function 抽取字符串类的字符串型参数
* @param flag 字符串
* @param options 参数数组
* @return
* @throws Exception
*/
public static String getOption(String flag, String[] options)throws Exception {
int i = getOptionPos(flag, options);
if (i > -1) {
if (options[i].equals("-" + flag)) {
if (i + 1 == options.length) {
throw new Exception("No value given for -" + flag
+ " option.");
}
options[i] = "";
String newString = new String(options[(i + 1)]);
options[(i + 1)] = "";
return newString;
}
if (options[i].charAt(1) == '-') {
return "";
}
} return "";
}
/**
* @function 抽取字符类的短整型参数
* @param flag 字符
* @param options 参数数组
* @return
* @throws Exception
*/
public static int getOptionPos(char flag, String[] options)
{
return getOptionPos("" + flag, options);
}
/**
* @function 抽取字符串类的短整型参数
* @param flag 字符
* @param options 参数数组
* @return
* @throws Exception
*/
public static int getOptionPos(String flag, String[] options) {
if (options == null) {
return -1;
}
for (int i = 0; i < options.length; ++i) {
if ((options[i].length() <= 0) || (options[i].charAt(0) != '-'))
continue;
try {
Double.valueOf(options[i]);
} catch (NumberFormatException e) {
if (options[i].equals("-" + flag)) {
return i;
}
if (options[i].charAt(1) == '-') {
return -1;
}
}
} return -1;
}
/**
* @function 把数据转换成字符串
* @param array
* @param splitPunc
* @return
*/
public static String array2String(String [] array , String splitPunc){
try{
StringBuilder sb = new StringBuilder();
for(String para : array){
if(sb.length() != 0)
sb.append(splitPunc);
sb.append(para);
}
return sb.toString();
}catch(Exception e){
e.printStackTrace();
return null;
}
}
public static String [] String2Array(String para , String splitPunc){
try{
return para.split(splitPunc);
}catch(Exception e){
e.printStackTrace();
return null;
}
}
/**
* @替换字符串中的某个参数
* @param para 参数字符串
* @param splitPunc 参数分隔符
* @param key 参数名称
* @param value 新参数值
* @return
*/
public static String replacePara(String para , String splitPunc , String key , String value){
try{
String [] parameter = String2Array(para,splitPunc);
replacePara(parameter, key, value);
return array2String(parameter, splitPunc);
}catch(Exception e){
e.printStackTrace();
return null;
}
}
/**
* @function 替换一个参数
* @param para 参数数组
* @param key 参数名称
* @param value 新参数值
* @return
*/
public static String [] replacePara(String [] para , String key , String value){
try{
for(int i = 0 ; i < para.length ; i++){
String paraName = para[i];
if(paraName.contains(key)){
int nextIndex = i + 1;
if(nextIndex < para.length){
if(!para[nextIndex].contains("-"))
para[nextIndex] = value;
}
}
}
return para;
}catch(Exception e){
e.printStackTrace();
return null;
}
}
}

    d) 生成arff文件的辅助类

 package com.lvxinjian.alg.models.generatefile; import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.Callable; import weka.core.Attribute;
import weka.core.FastVector;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.SparseInstance; import com.iminer.alg.models.getInstance.InstanceFactory;
import com.iminer.tool.common.util.FileTool; /**
* @Description : 生成arff文件的工具类
* @author : Lv Xinjian
*/
public class ArffFileUtils { /**
* @function 生成特征向量
* @param lexDataPath 特征文件路径
* @param words 保存特征词
* @param classifyAttribute 类别特征
* @return 特征向量
* @throws IOException 文件读取异常
*/
public static FastVector GetAttributes(String lexDataPath , List<String> words ,ClassifyAttribute classifyAttribute)
throws IOException {
HashMap<Integer, String> termId_term = FileTool.LoadIdStrFromFile(
lexDataPath, 0, 0, 1, "\t", Charset.forName("utf8"));
FastVector atts = new FastVector();
// - numeric
for (int tid = 0; tid < termId_term.size(); tid++) {
atts.addElement(new Attribute(termId_term.get(tid)));
words.add(termId_term.get(tid));
}
atts.addElement(new Attribute(classifyAttribute.getClassname(), classifyAttribute.getAttClassLabel())); System.out.println("atribute size :" + atts.size());
return atts;
}
/**
* @function 保存Arff文件
* @param data arff格式的数据
* @param outputPath 数据保存路径
* @return
*/
public static boolean savaInstances(Instances data , String outputPath)
{
try{
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream(outputPath), Charset.forName("utf-8"))); bw.write(data.toString());
bw.close();
}catch(Exception e){
e.printStackTrace();
return false;
}
return true;
}
}
/**
* @Description 分类器 类别特征
* @author Administrator
*
*/
class ClassifyAttribute{
/**
* 分类特征名 , 默认为"CLASS"
*/
private String classname = "CLASS";
private FastVector attClassLabel = new FastVector();
public ClassifyAttribute(String [] labels){
for(String label: labels){
this.attClassLabel.addElement(label);
}
}
public ClassifyAttribute(){}
/**
* @function 获取类别特征名
* @return
*/
public String getClassname() {
return classname;
}
/**
* @functoin 设置类别特征名
* @param classname
*/
public void setClassname(String classname) {
this.classname = classname;
}
/**
* @function 获取类别特征
* @return 类别特征
*/
public FastVector getAttClassLabel() {
return attClassLabel;
}
/**
* @function 设置类别特征
* @param attClassLabel
*/
public void setClassLabel(FastVector attClassLabel) {
this.attClassLabel = attClassLabel;
}
/**
* @function 设置类别特征分类标签
* @param labels
*/
public void setClassLabel(String [] labels) {
for(String label: labels){
this.attClassLabel.addElement(label);
}
} } /**
* @Description 把字符串转化成 instance实例
* @author Administrator
*
*/
class MyCallableClass implements Callable{
/**
* 输入的文本
*/
private String _text;
/**
* 文本的极性标签
*/
private double _labelVal;
/**
* 生成instance的方法
*/
private String _getInstancesMothed = null;
/**
* 获取instance方法 的 初始化词表
*/
private List<String> _set = null;
/**
* @function 构造函数,初始化参数
* @param labelVal 极性类别标签
* @param text 输入的文本内容
* @param set 获取instance方法 的 初始化词表
* @param getInstancesMothed 生成instance的方法
*/
public MyCallableClass(final double labelVal, String text ,List<String> set ,String getInstancesMothed)
{
this._text = text;
this._labelVal = labelVal;
this._getInstancesMothed = getInstancesMothed;
this._set = set; }
public Instance call() throws Exception{
double[] vals;
try {
//获取instance的double 数组
vals = InstanceFactory.getInstance(this._getInstancesMothed, this._set ).getInstanceFromText(this._text );
if (vals != null) {
vals[vals.length - 1] = _labelVal;
SparseInstance si = new SparseInstance(1.0, vals);
return si;
} } catch (Exception e) {
e.printStackTrace();
}
return null; }
}

    e) 以上代码缺少了几个类,但由于涉及到公司的保密制度,所以不方便上传。如有疑问,可以给我留言。(其实就是一个生成instance的方法,不过我的方法中揉了些东西进去,方法本身很简单,几行代码的事儿,有空我会补上)

四、小结

    1、考虑到抽取instance可能会有不同的需求,所以用了一个工厂类,这样方便 使用和新方法的添加。

    2、考虑到效率问题,所以使用了多线程进行生成。

    3、代码的结构、风格以及变量命名是硬伤,希望多多批评、指点。

微信扫一扫

支付宝扫一扫

本文网址:https://www.zhankr.net/141844.html

上一篇: kvm日常管理
相关推荐
python开发_常用的python模块及安装方法
adodb:我们领导推荐的数据库连接组件bsddb3:BerkeleyDB的连接组件Cheetah-1.0:我比较喜欢这个版本的cheeta…
日期:2022-11-24 点赞:875 阅读:5,075
Educational Codeforces Round 11 C. Hard Process 二分
C. Hard Process题目连接:http://www.codeforces.com/contest/660/problem/CDes…
日期:2022-11-24 点赞:806 阅读:3,505
下载Ubuntn 17.04 内核源代码
zengkefu@server1:/usr/src$ uname -aLinux server1 4.10.0-19-generic #21…
日期:2022-11-24 点赞:565 阅读:4,317
可用Active Desktop Calendar V7.86 注册码序列号
可用Active Desktop Calendar V7.86 注册码序列号Name: www.greendown.cn Code: &nb…
日期:2022-11-24 点赞:730 阅读:4,311
Android调用系统相机、自定义相机、处理大图片
Android调用系统相机和自定义相机实例本博文主要是介绍了android上使用相机进行拍照并显示的两种方式,并且由于涉及到要把拍到的照片显…
日期:2022-11-24 点赞:512 阅读:4,912
Struts的使用
一、Struts2的获取  Struts的官方网站为:http://struts.apache.org/  下载完Struts2的jar包,…
日期:2022-11-24 点赞:671 阅读:3,099
发表评论
暂无评论

还没有评论呢,快来抢沙发~

助力内容变现

将您的收入提升到一个新的水平

点击联系客服

在线时间:8:00-16:00

客服电话

400-888-8888

客服邮箱

ceotheme@ceo.com

扫描二维码

关注微信公众号

扫描二维码

手机访问本站