正文之前
事情是这样的，我前面说过了。。。。就是我的毕业论文字数写到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<Alone_Value_Category>{
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<Float,List<Alone_Value_Category> > sample = new HashMap<Float, List<Alone_Value_Category>>();
Interval(){};
Interval(Interval b){
top = b.top;
bottom = b.bottom;
sample = b.sample;
}
Interval(float a, float b, float c, List<Alone_Value_Category> 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<Float, List<Alone_Value_Category>> 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 (bottom<b.bottom) re.setBottom(bottom);
else re.setBottom(b.bottom);
re.sample.putAll(sample);
return re;
}
public void merge(Interval b){
if (top<b.top)
top = b.top;
if (bottom>b.bottom)
bottom = b.bottom;
sample.putAll(b.sample);
}
public int getCount(){
int count = 0;
for(List<Alone_Value_Category> 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<Interval> allInterval){
ArrayList<Interval> del = new ArrayList<>();
for (int s = 0;s<allInterval.size();++s) {
if (allInterval.get(s).getCount() == 0){
if (s>0) {
allInterval.get(s - 1).merge(allInterval.get(s));
del.add(allInterval.get(s));
}
continue;
}
}
allInterval.removeAll(del);
}
static double Entropy(ArrayList<Interval> 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<List<Float>> EADC(float[][] dat) {
ArrayList<List<Float>> re = new ArrayList<>();
for (int valueindex = 0; valueindex< dat[0].length-1;++valueindex) {
ArrayList<Alone_Value_Category> 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<Float> range = new LinkedList<>();
for (int x = 0; x <= k; ++x) {
range.add(Float.parseFloat(nf.format(Lowest + x * gap)));
}
ArrayList<Interval> 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<Interval> 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） 将传入的数据根据当前区间划分进行离散化。
离散化流程图如下：
上面这图花了好久。才算是理清了。。。不容易啊不容易！！
正文之后
争取今晚写完论文，明天排版完毕，最好事明天先自查，然后大后天上知网查重。。。大大后天，要给某人一个惊喜，就是不知道她能不能看到了！！
