正文之前
事情是这样的,我前面说过了。。。。就是我的毕业论文字数写到14200的时候就感觉有点写不动了,虽然还有性能度量和致谢和一大批的文献参考没写,但是我总感觉这样不妥,所以就特地的又加了点东西。在后剪枝方法和连续值离散化之间,我选择了离散化这个相对好点的东西。后剪枝感觉没什么好补充的。。
正文
从不废话,先放代码!
/* *********************
* Author : HustWolf --- 张照博
* Time : 2018.1-2018.5
* Address : HUST
* Version : 1.0
* 定义一些静态的数值,并且提供getter
********************* */
import java.text.NumberFormat;
import java.util.*;
class Alone_Value_Category implements Comparable{
private float sensor;
private float category;
// private float[] range = new float[2];
Alone_Value_Category(float a, float b){
super();
this.sensor = a;
this.category = b;
}
float getSensor(){
return sensor;
}
float getCategory(){
return category;
}
// void setRange(float a, float b){
// range[0] = a;
// range[1] =b;
// }
@Override
public String toString() {
return "\n[Sensor:" + sensor + ", category=" + category + "]";
}
@Override
public int compareTo(Alone_Value_Category o) {
return Float.compare(this.sensor,o.sensor);
}
}
上面这个是定义的一个存储数据的地方,这个类用来分割数据,做到单属性对分类的格式。一条4 Sensor 1Category 一共会被拆解为4个这种类的实例分别参与EADC离散化的过程。
class Interval{
private float top;
private float bottom;
public Map > sample = new HashMap>();
Interval(){};
Interval(Interval b){
top = b.top;
bottom = b.bottom;
sample = b.sample;
}
Interval(float a, float b, float c, List d){
this.top = a;
this.bottom = b;
sample.put(c,d);
}
public float getTop() {
return top;
}
public float getBottom() {
return bottom;
}
public void setTop(float top) {
this.top = top;
}
public void setBottom(float bottom) {
this.bottom = bottom;
}
public void setSample(Map> sample) {
this.sample = sample;
}
public Interval addTmp(Interval b){
Interval re = new Interval(b);
if (top>b.top) re.setTop(top);
else re.setTop(b.top);
if (bottomb.bottom)
bottom = b.bottom;
sample.putAll(b.sample);
}
public int getCount(){
int count = 0;
for(List s:sample.values()){
count+=s.size();
}
return count;
}
@Override
public String toString() {
return "bottom:"+bottom+" top:"+top+" size:"+getCount();
}
}
区间类,每一个区间有上界,下界,还有对应的Alone_Value_Category集合。不过这里面的集合是按照类别-->List的模式存储。按照我的数据,应该是每一个Interval都有两个List
public class Parameter {
private static int rate = 2;
private static int trainNum = 40000;
private static int testNum = trainNum/rate;
public static int getTrainNum(){
return trainNum;
}
public static int getRate(){
return rate;
}
public static int getTestNum(){
return testNum;
}
public static int getTestDistance(){
return 2000000/testNum;
}
public static int getTrainDistance(){
return 2000000/trainNum;
}
public static void setRate(int r){
rate = r;
testNum = trainNum / rate;
}
public static void setTrainNum(int t){
trainNum = t;
testNum = trainNum / rate;
}
public static void setTestNum(int t){
testNum = t;
trainNum = testNum * rate;
}
public static void Clear(ArrayList allInterval){
ArrayList del = new ArrayList<>();
for (int s = 0;s0) {
allInterval.get(s - 1).merge(allInterval.get(s));
del.add(allInterval.get(s));
}
continue;
}
}
allInterval.removeAll(del);
}
static double Entropy(ArrayList set, int size){
double shang = 0;
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(4);
for (Interval x:set){
double p =(double)x.getCount()/(double)size;
shang -= p*(Math.log(p)/Math.log(2));
}
return Double.parseDouble(nf.format(shang));
}
public static ArrayList> EADC(float[][] dat) {
ArrayList> re = new ArrayList<>();
for (int valueindex = 0; valueindex< dat[0].length-1;++valueindex) {
ArrayList LIST = new ArrayList<>();
for (int i = 0; i < dat.length; ++i) {
LIST.add(new Alone_Value_Category(dat[i][valueindex], dat[i][dat[valueindex].length - 1]));
//便利旧集合没有就添加到新集合
}
Collections.sort(LIST);
float len = LIST.get(LIST.size() - 1).getSensor() - LIST.get(0).getSensor();
int k = 40;
float gap = (len + 1) / k;
float Lowest = LIST.get(0).getSensor() - 0.50f;
float Highest = LIST.get(LIST.size()-1).getSensor() + 0.50f;
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(1);
List range = new LinkedList<>();
for (int x = 0; x <= k; ++x) {
range.add(Float.parseFloat(nf.format(Lowest + x * gap)));
}
ArrayList allInterval = new ArrayList<>();
for (int i = 0; i < k; ++i) {
Interval newarea = new Interval();
newarea.setBottom(range.get(i));
newarea.setTop(range.get(i + 1));
for (Alone_Value_Category s : LIST) {
if (s.getSensor() > range.get(i) && s.getSensor() < range.get(i + 1)) {
if (!newarea.sample.containsKey(s.getCategory())) {
newarea.sample.put(s.getCategory(), new LinkedList<>());
}
newarea.sample.get(s.getCategory()).add(s);
}
}
allInterval.add(newarea);
}
int size = 0;
Clear(allInterval);
for (Interval s : allInterval) {
size += s.getCount();
}
k = allInterval.size();
int k0 = k;
double Ck0 = 0.5;
boolean Loop = true;
double Hpk_1 = 0;
while (Loop && k >= 10) {
double minD = 1000;
int mergePoint = 0;
double Hp0 = Entropy(allInterval, size);
double Hpk;
ArrayList newA = new ArrayList<>();
for (int i = 0; i < allInterval.size() - 1; ++i) {
newA.addAll(allInterval);
newA.get(i).merge(newA.get(i + 1));
newA.remove(i + 1);
Hpk = Entropy(newA, size);
if (Hpk - Hp0 < minD) {
Hpk_1 = Hpk;
minD = Hpk - Hp0;
mergePoint = i;
}
newA.clear();
}
allInterval.get(mergePoint).merge(allInterval.get(mergePoint + 1));
allInterval.remove(allInterval.get(mergePoint + 1));
double Ck_1 = (k0 - 1) * Hpk_1 - Hp0 * (k - 2);
if (Ck_1 > Ck0) {
--k;
} else {
Loop = false;
--k;
}
// Ck = Ck_1;
}
range.clear();
range.add(-100f);
for (Interval s:allInterval) {
range.add(s.getTop());
}
range.add(100f);
re.add(range);
// long endTime=System.currentTimeMillis(); //获取结束时间
// System.out.println("\n程序运行时间: "+(endTime-startTime)+"ms");
}
return re;
}
}
主体类,也是EADC算法的(一种基于熵的连续属性离散化算法)的Java实现!我是三天晒网,一天打渔,不过终于今天还是肝出来了。。这就意味着差不多要收工了!美滋滋Q!!!
具体来说其实还好吧。。。等后面毕业了我把我的毕业论文写成发出来,大家伙就看的明白了咯!现在先上数学表达!
最后得到的伪代码就是下面的了:
当然,他这个有点看不明白,看我的解释吧!
整个离散化的过程如下:
(1) 从数据库读取数据,传入到离散化方法中;
(2) 先针对单一的属性,取出所有的值,并且对其进行排序;
(3) 排序后划分区间,并且利用熵的计算公式计算出初始熵,设置度量数值Ck = 0 ;
(4) 合并两个相邻区间,使合并前后的熵差最小,并且重置划分点,保存合并后的熵值;
(5) 根据上面的度量公式计算出Ck-1 = h;
(6) 如果Ck-1 > Ck ,那么k = k -1,回到第(4)步;
(7) 如果Ck-1 < Ck ,保存当前的区间划分,结束区间划分进程;
(8) 将传入的数据根据当前区间划分进行离散化。
离散化流程图如下:
上面这图花了好久。才算是理清了。。。不容易啊不容易!!
正文之后
争取今晚写完论文,明天排版完毕,最好事明天先自查,然后大后天上知网查重。。。大大后天,要给某人一个惊喜,就是不知道她能不能看到了!!