精华内容
下载资源
问答
  • 利用邻域粗糙集进行属性约简,里面加入了8个数据集,有离散型数据,连续性数据,字母型数据。因此程序也加入了数据类型转换和归一化处理。程序函数在最下面部分。
  • 粗糙集属性约简方法

    2012-03-30 11:25:01
    介绍粗糙集的概念和属性约简的概念,并给出了属性约简的方法和实例
  • 结合模糊关系的理论,对粗糙集理论的属性约简算法进行研究,提出了一个新的属性约简算法,并给出了一个应用实例
  • 关于粗糙集的简单介绍及其各种属性约简算法的研究,并且有实例分析。
  • 粗糙集属性约简属于NP问题,这就使得粗糙集很难在现实中得到广泛的应用。利用蚁群算法的搜索技术,可以很好地解决这一难题。它不仅能得到最小约简属性集,而且可以得到很多的约简属性集.本文以具体的实例,通过...
  • 结合模糊关系的理论,对粗糙集理论的属性约简算法进行研究,提出了一个新的属性约简算法,并给出了一个应用实例
  • 介绍了粗糙集的布尔矩阵表示及其重要性,重点研究了基于条件区分能力的属性约简及其改进算法,构造了基于核与条件区分能力、加权条件区分能力的两种属性约简算法,提高了数据挖掘速度。通过实例证明了该算法的有效性。
  • 粗糙集属性约简算法源码MATLAB

    热门讨论 2009-11-11 10:49:57
    鲁东大学张小峰编制,源码丰富却简洁,简单易懂,模块分明,适合粗糙集初学者学习。
  • 为了大家能够更好的实现粗糙集属性约简以及了解相关知识,在这里给出了构造决策表部分的代码,希望读者通过阅读代码自己实现一些论文中的简单算法,,,代码中有什么不懂得可以与我交流,论文代码实现也可以与我一起...

    为了大家能够更好的实现粗糙集属性约简以及了解相关知识,在这里给出了构造决策表部分的代码,希望读者通过阅读代码自己实现一些论文中的简单算法,,,代码中有什么不懂得可以与我交流,论文代码实现也可以与我一起探讨,互相学习。

    import java.util.ArrayList;
    import java.util.Iterator;
    public class MyElement implements Cloneable
    {
    public MyElement(){}
    public MyElement(ArrayList condition, ArrayList decision, int iNo)
    {
    this.valueOfCondition = condition;
    this.valueOfDecision = decision;
    this.u = iNo;
    }
    public MyElement(MySet condition, MySet decision, int iNo)
    {
    this.valueOfCondition = condition.toIntArrayList();
    this.valueOfDecision = condition.toIntArrayList();
    this.u = iNo;
    }
    public MyElement clone() throws CloneNotSupportedException
    {
    MyElement cloned = new MyElement();
    cloned.u = this.getU();
    Iterator itCondition = this.getCondition().iterator();
    while(itCondition.hasNext())
    {
    cloned.valueOfCondition.add(itCondition.next());
    }
    Iterator itDecision = this.getDecision().iterator();
    while(itDecision.hasNext())
    {
    cloned.valueOfDecision.add(itDecision.next());
    }
    return cloned;
    }
    public ArrayList getCondition()
    {
    return this.valueOfCondition;
    }
    public ArrayList getDecision()
    {
    return this.valueOfDecision;
    }
    public int getU()
    {
    return this.u;
    }
    void setCondition(ArrayList condition)
    {
    this.valueOfCondition = condition;
    }
    void setDecision(ArrayList decision)
    {
    this.valueOfDecision = decision;
    }
    void setU(int u)
    {
    this.u = u;
    }
    boolean isConditionEqual(MyElement another)
    {
    Iterator it1 = this.valueOfCondition.iterator();
    Iterator it2 = another.valueOfCondition.iterator();

    	while(it1.hasNext() && it2.hasNext())
    	{
    		if(it1.next() != it2.next())
    			return false;
    	}
    	return true;
    }
    boolean isDecisionEqual(MyElement another)
    {
    	Iterator<Float> it1 = this.getDecision().iterator();
    	Iterator<Float> it2 = another.getDecision().iterator();
    	
    	while(it1.hasNext() && it2.hasNext())
    	{
    		if(it1.next() != it2.next())
    			return false;
    	}
    	return true;
    }
    boolean isUEqual(MyElement another)
    {
    	if(this.getU() != another.getU())
    		return false;
    	else 
    		return true;
    }
    boolean isEqual(MyElement another)
    {
    	if(this.isConditionEqual(another) && this.isDecisionEqual(another))
    		return true;
    	else 
    		return false;
    }
    void removeConditionAttribute(int it)
    {
    	this.valueOfCondition.remove(it);
    }
    void addConditionAttribute(Float a)
    {
    	this.valueOfCondition.add(a);
    }
    void print()
    {
    	if(!this.valueOfCondition.isEmpty() && !this.valueOfDecision.isEmpty())
    	{
    		System.out.print("(");
    		Iterator<Float> it = this.valueOfCondition.iterator();
    		System.out.print(it.next());
    		while(it.hasNext())
    		{
    			System.out.print(",\t" + it.next());
    		}
    		System.out.print(")\t->\t(");
    		it = this.valueOfDecision.iterator();
    		System.out.print(it.next());
    		while(it.hasNext())
    		{
    			System.out.print(",\t" + it.next());
    		}
    		System.out.println(")\tu" + u);
    	}
    	else
    		System.out.println("该样本不符合条件,无意义");
    }
    
    private ArrayList<Float> valueOfCondition = new ArrayList<Float>(0);
    private ArrayList<Float> valueOfDecision = new ArrayList<Float>(0);
    private int u;
    

    }

    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.LinkedHashMap;
    import java.util.LinkedList;
    import java.util.Map;
    import java.util.Scanner;
    import java.io.;
    import java.math.
    ;
    public class DecisionTable implements Cloneable
    {
    private static final Float Interger = null;
    public static int iNo;
    public DecisionTable()
    {

    }
    public DecisionTable(String fileName)
    {
    	try
    	{
    		File file = new File(fileName);
    		Scanner in = new Scanner(file);
    		String[] temp;
    		while(in.hasNextLine())
    		{
    			temp = in.nextLine().split(" |,");
    			
    			if(temp[0].equals( "@conditionAttribute"))
    			{
    

    // System.out.println("#####"+temp.length);
    for(int i=1; i<temp.length; i++)
    {
    // System.out.print(" "+(temp[i]));
    this.conditionSet.add( Integer.parseInt(temp[i]));

    				}
    			}
    			else if(temp[0].equals("@decisionAttribute"))
    			{
    				for(int i=1; i<temp.length; i++)
    				{
    					this.decisionSet.add(Integer.parseInt(temp[i]));
    				}
    			}
    			else if(temp[0].equals("%") || temp[0].equals("@data"))
    			{
    				continue;
    			}
    			else if(temp[0].equals("@end"))
    			{
    				break;
    			}
    	
    			else if(Float.parseFloat(temp[0]) < Float.MAX_VALUE)
    			{
    				MyElement e = new MyElement();
    				int i = 0;
    				ArrayList<Float> C = new ArrayList<Float>(0);
    				ArrayList<Float> D = new ArrayList<Float>(0);
    				for(; i< this.conditionSet.size(); i++)
    				{
    					C.add(Float.parseFloat(temp[i]));
    					
    				}
    				for(int j=0; j<this.decisionSet.size(); j++)
    				{
    					D.add(Float.parseFloat(temp[i+j]));
    				}
    				e.setCondition(C);
    				e.setDecision(D);
    				this.addElement(e);
    			}
    			else
    			{
    				System.out.print(temp[0]+"!!!");
    				System.out.println("数据数目有误,请检查");
    				break;
    			}
    		}
    
    	}
    
    	catch(IOException e)
    	{
    		
    		System.out.print("不能打开文件" + fileName + " " + e.getMessage());
    	}
    }
    public DecisionTable clone() throws CloneNotSupportedException
    {
    	DecisionTable cloned = new DecisionTable();
    	
    	cloned.conditionSet = (ArrayList<Integer>)this.conditionSet.clone();
    	cloned.decisionSet = (ArrayList<Integer>)this.decisionSet.clone();
    	ArrayList<MyElement> arrayElements = new ArrayList<MyElement>(0);
    	MyElement tempElement = new MyElement();
    	Iterator<MyElement> itElements = this.DT.iterator();
    	while(itElements.hasNext())
    	{
    		tempElement = itElements.next().clone();
    		arrayElements.add(tempElement);
    	}
    	cloned.DT = arrayElements;
    	
    	return cloned;
    }
    public float [][]  to_Condition_table(){
    	ArrayList<MyElement> temp = this.getDT();
    	float table[][] = new float[temp.size()][this.conditionSet.size()];
    	Iterator<MyElement> itElements = this.DT.iterator();
    	for(int i = 0 ; i < this.numberOfElements() ;i++){
    		for(int j = 0 ; j < this.conditionSet.size() ; j++ ){
    			table[i][j] = temp.get(i).getCondition().get(j);
    		}
    	}
    	return table;
    	
    }	
    
    public float [][]  to_Decision_table(){
    	ArrayList<MyElement> temp = this.getDT();
    	float table[][] = new float[temp.size()][this.decisionSet.size()];
    	Iterator<MyElement> itElements = this.DT.iterator();
    	for(int i = 0 ; i < this.numberOfElements() ;i++){
    		for(int j = 0 ; j < this.decisionSet.size() ; j++ ){
    			table[i][j] = temp.get(i).getDecision().get(j);
    		}
    	}
    	return table;
    	
    }	
    void setConditionSet(ArrayList<Integer> condition)
    {
    	this.conditionSet = condition;
    }
    void setDecisionSet(ArrayList<Integer> decision)
    {
    	this.decisionSet = decision;
    }
    void setU(int index, int newU)
    {
    	MyElement temp = DT.get(index);
    	temp.setU(newU);
    	DT.set(index,temp);
    }
    ArrayList<Integer> getConditionSet()
    {
    	return this.conditionSet;
    }
    ArrayList<Integer> getDecisionSet()
    {
    	return this.decisionSet;
    }
    ArrayList<MyElement> getDT()
    {
    	return DT;
    }
    MyElement getElement(float f)
    {
    	MyElement temp = new MyElement();
    	Iterator<MyElement> it = this.DT.iterator();
    	while(it.hasNext())
    	{
    		temp = it.next();
    		if(temp.getU() == f)
    		{
    			return temp;
    		}
    	}
    	System.out.println("不存在你所指定的样本");
    	return null;
    }
    
    //返回决策表DT中的样本数
    int numberOfElements()
    {
    	return DT.size();	
    }
    void addElement(MyElement e)
    {
    	this.serialNumberOfElement++;
    	if(DecisionTable.iNo < Integer.MAX_VALUE)
    	{
    		e.setU(this.serialNumberOfElement);
    		DT.add(e);
    	}
    	else
    	{
    		System.out.println("可用编号已耗尽,添加样本失败");
    	}
    }
    void addElement(MyElement e, boolean flag)
    {
    	if(flag)
    	{
    		this.addElement(e);
    	}
    	else
    	{
    		DT.add(e);
    	}
    }
    int findElement(MyElement e)
    {
    	Iterator<MyElement> it = this.DT.iterator();
    	while(it.hasNext())
    	{
    		MyElement temp = it.next();
    		if(temp.equals(e))
    		{
    			return temp.getU();
    		}
    	}
    	return -1;
    }
    void removeElement(int iNo)
    {
    	if(iNo >= 1 && iNo <= this.serialNumberOfElement)
    	{
    		Iterator<MyElement> it = this.DT.iterator();
    		while(it.hasNext())
    		{
    			if(it.next().getU() == iNo)
    			{
    				this.DT.remove(iNo);
    				break;
    			}
    		}
    	}
    	else
    	{
    		System.out.println("越界,不存在这样的样本");
    	}
    }
    boolean containsConditionAttribute(int c )
    {
    	Iterator<Integer> itConditionAttr = this.getConditionSet().iterator();
    	while(itConditionAttr.hasNext())
    	{
    		if(itConditionAttr.next() == c)
    			return true;
    	}
    	return false;
    }
    boolean containsDecisionAttribute(int d)
    {
    	Iterator<Integer> itConditionAttr = this.getDecisionSet().iterator();
    	while(itConditionAttr.hasNext())
    	{
    		if(itConditionAttr.next() == d)
    			return true;
    	}
    	return false;
    }
    DecisionTable removeConditionAttribute(int c)
    {
    	int index =0;
    	Iterator<Integer> it = this.conditionSet.iterator();
    	int temp;
    	while(it.hasNext())
    	{
    		index++;
    		temp = it.next();
    		if(temp == c)
    		{//有可能位置有问题;
    			it.remove();
    			break;
    		}
    	}
    	index--;
    	Iterator<MyElement> itEle = this.DT.iterator();
    	while(itEle.hasNext())
    	{
    		itEle.next().removeConditionAttribute(index);
    	}
    	return this;
    }
    MySet POS()
    {
    	boolean flag;
    	MySet pos = new MySet();
    	Iterator<MyElement> it1 = this.DT.iterator();
    	Iterator<MyElement> it2;
    	MyElement temp1 = new MyElement(),temp2 = new MyElement();
    	while(it1.hasNext())
    	{
    		temp1 = it1.next();
    		flag = true;
    		it2 = this.DT.iterator();
    		while(it2.hasNext())
    		{
    			temp2 = it2.next();
    			if(temp1.isConditionEqual(temp2) && !temp1.isDecisionEqual(temp2))
    			{
    				flag = false;
    				break;
    			}
    		}
    		if(flag)
    		{
    			pos.add(temp1.getU());
    		}
    	}
    	return pos;
    }
    double relyDegreeOfDToC()
    {
    	double result = 0.0d;
    	MySet pos = this.POS();
    	
    	result = (double) pos.card() / this.numberOfElements();
    	
    	return result;
    }
    float relyDegreeOfDToc(float x)
    {
    	float result = 0.0f;
    	
    	result = (float) x / this.numberOfElements();
    		
    	return result;
    }
    double relyDegreeOfDToAttribute(int c) throws CloneNotSupportedException
    {
    	DecisionTable temp = (DecisionTable)this.clone();
    	Iterator<Integer> it = temp.conditionSet.iterator();
    	double result = 0.0d;
    	int nowCondition;
    	while(it.hasNext())
    	{
    		nowCondition = it.next();
    		if(c != nowCondition)
    		{
    			temp.removeConditionAttribute(nowCondition);
    		}
    	}
    	MySet pos = temp.POS();
    	result = (double)pos.card() / this.numberOfElements();
    	return result;
    }
    double sigOfAttribute(int c) throws CloneNotSupportedException
    {
    	double sig = 0.0d;
    	double x,y;
    	DecisionTable temp = (DecisionTable)this.clone();
    	temp.removeConditionAttribute(c);
    	MySet posx = this.POS();
    	x = (double) posx.card() / this.numberOfElements();
    	MySet posy = temp.POS();
    	y = (double) posy.card() / temp.numberOfElements();
    	sig = x- y;
    	return sig;
    }
    float sigOfC(ArrayList<Integer> alChar) throws CloneNotSupportedException
    {
    	float sig_C ;
    	sig_C = 0;
    	DecisionTable temp = (DecisionTable)this.clone();
    
    	Iterator<MySet> equClass = temp.equivalenceClass2(alChar).iterator();
    	while(equClass.hasNext())
    	{
    		MySet tt=equClass.next();
    		sig_C += ((float)tt.card()/temp.numberOfElements())*
    				(    (float)Math.log(  (double)tt.card()/temp.numberOfElements()    )/ (float)Math.log ((double)2)  );	
    	}
    	return  (float) (sig_C*(-1.0)); 
    }
    ArrayList<Integer> core() throws CloneNotSupportedException
    {
    	ArrayList<Integer> temp = new ArrayList<Integer>(0);
    	Iterator<Integer> it = this.getConditionSet().iterator();
    	int tmpChar;
    	while(it.hasNext())
    	{
    		tmpChar = it.next();
    		if(this.sigOfAttribute(tmpChar) != 0)
    		{
    			temp.add(tmpChar);
    		}
    	}
    	return temp;
    }
    MySet lowerApproximation(ArrayList<Integer> alChar) throws CloneNotSupportedException{
    	Iterator<Integer> itPara = alChar.iterator();
    	ArrayList<MySet> equClass = new ArrayList<MySet>(0);
    	boolean availablePara_C = true;
    	while(itPara.hasNext()){
    		int temp_At=itPara.next();
    	
    		
    		if(!this.containsConditionAttribute(temp_At)){
    

    // System.out.println(temp_At+" ###");
    availablePara_C = false;
    }
    }
    if(availablePara_C){
    MySet lowAppSet = new MySet();
    ArrayList d = new ArrayList(0);
    d.addAll(this.getDecisionSet());
    ArrayList equClass_D = this.equivalenceClass2(d);
    ArrayList equClass_C = this.equivalenceClass2(alChar);
    Iterator itSet_D = equClass_D.iterator();
    while(itSet_D.hasNext()){
    Iterator itSet_C = equClass_C.iterator();
    MySet temp_C = new MySet();
    MySet temp_D = new MySet();
    temp_D = itSet_D.next();
    while(itSet_C.hasNext()){
    temp_C=itSet_C.next();
    if(temp_C.belongTo(temp_D)){
    lowAppSet.union(temp_C);
    }
    }
    }
    lowAppSet.sort();
    return lowAppSet;
    }
    else{
    System.out.println(“您输入的属性不存在,不能为您求下近似”);
    return null;
    }

    }
    //H(D|C)
    float sigOfC_D(ArrayList<Integer> alChar) throws CloneNotSupportedException
    {
    	float sig_C ;
    	sig_C = 0;
    	DecisionTable temp = (DecisionTable)this.clone();      
    	Iterator<MySet> equClass_c = temp.equivalenceClass2(alChar).iterator();
    	while(equClass_c.hasNext())
    	{
    		MySet C_i=equClass_c.next();
    		Iterator<Integer> itAllDecisionAttr= this.getDecisionSet().iterator();
    		DecisionTable tempDT = (DecisionTable)this.clone();
    		int U = C_i.card();
    		ArrayList<Boolean> flag = new ArrayList<Boolean>(0);
    		
    		for(int i=0; i < U ; i++){
    			flag.add(false);
    		}
    
    		ArrayList<MySet> equClass = new ArrayList<MySet>(0);
    		
    		for(int i=0 ; i< U ; i++){	
    			int s = (int)C_i.keyAt(i);
    			if(flag.get(i)!= true ){
    				MySet temp1 = new MySet();
    				temp1.add(s);
    				flag.set(i,true);
    				for(int j=i+1; j < U ; j++){
    					int s2 = (int)C_i.keyAt(j);			
    					if(flag.get(j) !=  true){							
    						if(tempDT.getElement(s).getDecision().equals(tempDT.getElement(s2).getDecision())){				
    							temp1.add(s2);
    							flag.set(j, true);
    						}
    					}
    				}
    				equClass.add(temp1);
    			}
    		}
    		float sig_t = 0;
    		Iterator<MySet> fff = equClass.iterator();
    		while(fff.hasNext()){
    			float  P_x = (float)C_i.card();
    			float  p_xy = (float)fff.next().toIntArrayList().size();
    			sig_t += (p_xy/P_x)*(   (float)  Math.log((double)(p_xy / P_x) ) / Math.log((double)2) );
    
    		}
    		sig_t = sig_t*((float)C_i.card()/temp.numberOfElements());
    		sig_C += sig_t;
    	}
    	return  (float) (sig_C*(-1.0)); 
    }	
    ArrayList<MySet> equivalenceClass2(ArrayList<Integer> alChar) throws CloneNotSupportedException{
    	boolean availablePara_C = true,availablePara_D=true;
    	Iterator<Integer> itPara = alChar.iterator();
    	while(itPara.hasNext()){
    		int temp_At=itPara.next();
    		if(!this.containsConditionAttribute(temp_At))
    			availablePara_C = false;
    		if(!this.containsDecisionAttribute(temp_At))
    			availablePara_D = false;
    	}
    	if(availablePara_C && !availablePara_D){
    		ArrayList<Integer> conditionsToBeDeleted = new ArrayList<Integer>(0);
    		Iterator<Integer> itAllConditionAttr= this.getConditionSet().iterator();
    		int tempChar;
    		while(itAllConditionAttr.hasNext()){
    			tempChar = itAllConditionAttr.next();
    			//判断是否为其余属性
    			if(!alChar.contains(tempChar)){
    				conditionsToBeDeleted.add(tempChar);
    			}
    		}
    		Iterator<Integer> itconditionsToBeDeleted = conditionsToBeDeleted.iterator();
    		DecisionTable tempDT = (DecisionTable)this.clone();
    		while(itconditionsToBeDeleted.hasNext()){
    			tempDT.removeConditionAttribute(itconditionsToBeDeleted.next());		
    		}
    		int U = tempDT.numberOfElements();
    		int length = tempDT.getConditionSet().size();	
    		float ss[][] = tempDT.to_Condition_table();
    		float M_m[][] = new float [length][2];
             
    		for(int j = 0 ; j < length;j++){
    			M_m[j][0]=-1f;
        		M_m[j][1]=1000000f;
    		}
        
    		for(int j = 0 ; j < length;j++){
    			for(int i = 0 ; i < U ; i++){
    				M_m[j][0]=Math.max(M_m[j][0], ss[i][j]);
    				M_m[j][1]=Math.min(M_m[j][1], ss[i][j]);
    			}
    		}
        
    		ArrayList<Integer> List = new ArrayList<Integer>(0);
    		Iterator<MyElement> it = tempDT.getDT().iterator();
    	
    		while(it.hasNext()){
    			List.add(it.next().getU());			}	
    
    		for(int i = 0 ; i < length ; i++){		//3,for(i =1 ; i <S+1;i++)
    			Map<Integer,LinkedList> que = new LinkedHashMap<Integer,LinkedList>();
    			int tem =  (int) ((int)M_m[i][0]-(int)M_m[i][1]+1);
    			for(int k  = 0 ; k < tem ; k++){   //j建立Mi-mi+1空队列
    				LinkedList lk = new LinkedList();
    				que.put(k,lk);
    			}
    			for(int j = 0 ; j < List.size() ; j++){
    				int num = List.get(j);        
    				Float e = tempDT.getElement(num).getCondition().get(i);	
    				LinkedList lk = (LinkedList) que.get((int)(e - M_m[i][1]));
    				lk.add(num);
    				que.put((int)(e - M_m[i][1]),lk);
    			}
    
    			List.clear();
    			for(int j = 0 ; j < que.size(); j++){//第i趟收集结果
    				List.addAll(que.get(j));
    			}
    		}
    	
    		ArrayList<MySet> equClass = new ArrayList<MySet>(0);
    		MySet temp = new MySet();	
    		temp.add(List.get(0));
    	
    		for(int i = 1 ; i < List.size() ; i++){//第i条记录
    			boolean  flag =  true;
    			for(int j = 0 ;  j < length ; j++){//第j个属性
    				float  f_j_i=tempDT.getElement(List.get(i)).getCondition().get(j);  //第i条记录第j个属性的取值
    				float  f_j2_i = tempDT.getElement(List.get(i-1)).getCondition().get(j);  //第i-1条记录第j个属性的取值
    

    // System.out.println(List.get(i)+" : “+f_j_i+” “+List.get(i-1)+” :"+f_j2_i+" “+j);
    if(f_j_i != f_j2_i){
    flag = false;
    break;
    }
    }
    if(flag){
    temp.add(List.get(i));
    if(iList.size()-1){
    MySet temp3 = new MySet();
    for(int k = 0 ; k < temp.card() ; k++){
    temp3.add(temp.keyAt(k));
    }
    equClass.add(temp3);
    }
    }
    else{
    // System.out.println(temp.toIntArrayList()+" 第 “+i+” ci");
    MySet temp2 = new MySet();
    for(int k = 0 ; k < temp.card() ; k++){
    temp2.add(temp.keyAt(k));
    }
    equClass.add(temp2);
    // System.out.println("#### “+temp2.toIntArrayList());
    temp.clear();
    temp.add(List.get(i));
    // System.out.println(”#### “+temp.toIntArrayList()+” “+List.get(i)+” "+i);
    if(i
    List.size()-1){
    MySet temp3 = new MySet();
    // System.out.println(”*** “+temp.toIntArrayList()+” “+List.get(i)+” "+i);
    temp3.add(temp.keyAt(0));
    equClass.add(temp3);
    }
    }
    }
    return equClass;
    }
    else if(!availablePara_C && availablePara_D){
    Iterator itAllDecisionAttr= this.getDecisionSet().iterator();
    DecisionTable tempDT = (DecisionTable)this.clone();
    int U = tempDT.numberOfElements();
    int length = tempDT.getDecisionSet().size();
    float ss[][] = tempDT.to_Decision_table();
    float M_m[][] = new float [length][2];

    		for(int j = 0 ; j < length;j++){
    			M_m[j][0]=-1f;
        		M_m[j][1]=1000000f;
    		}
        
    		for(int j = 0 ; j < length;j++){
    			for(int i = 0 ; i < U ; i++){
    				M_m[j][0]=Math.max(M_m[j][0], ss[i][j]);
    				M_m[j][1]=Math.min(M_m[j][1], ss[i][j]);
    			}
    		}
        
    		ArrayList<Integer> List = new ArrayList<Integer>(0);
    		Iterator<MyElement> it = tempDT.getDT().iterator();
    	
    		while(it.hasNext()){
    			List.add(it.next().getU());		//保存x1,x2,xn编号
    		}	
    
    		for(int i = 0 ; i < length ; i++){		//3,for(i =1 ; i <S+1;i++)
    			Map<Integer,LinkedList> que = new LinkedHashMap<Integer,LinkedList>();
    			int tem =  (int) ((int)M_m[i][0]-(int)M_m[i][1]+1);
    			for(int k  = 0 ; k < tem ; k++){   //j建立Mi-mi+1空队列
    				LinkedList lk = new LinkedList();
    				que.put(k,lk);
    			}
    			for(int j = 0 ; j < List.size() ; j++){
    				int num = List.get(j);        
    				Float e = tempDT.getElement(num).getDecision().get(i);	
    				LinkedList lk = (LinkedList) que.get((int)(e - M_m[i][1]));
    				lk.add(num);
    				que.put((int)(e - M_m[i][1]),lk);
    			}
    
    			List.clear();
    			for(int j = 0 ; j < que.size(); j++){//第i趟收集结果
    				List.addAll(que.get(j));
    			}
    		}
    	
    		ArrayList<MySet> equClass = new ArrayList<MySet>(0);
    		MySet temp = new MySet();	
    		temp.add(List.get(0));
    	
    		for(int i = 1 ; i < List.size() ; i++){//第i条记录
    			boolean  flag =  true;
    			for(int j = 0 ;  j < length ; j++){//第j个属性
    				float  f_j_i=tempDT.getElement(List.get(i)).getDecision().get(j);  //第i条记录第j个属性的取值
    				float  f_j2_i = tempDT.getElement(List.get(i-1)).getDecision().get(j);  //第i-1条记录第j个属性的取值
    

    // System.out.println(List.get(i)+" : “+f_j_i+” “+List.get(i-1)+” :"+f_j2_i+" “+j);
    if(f_j_i != f_j2_i){
    flag = false;
    break;
    }
    }
    if(flag){
    temp.add(List.get(i));
    if(iList.size()-1){
    MySet temp3 = new MySet();
    for(int k = 0 ; k < temp.card() ; k++){
    temp3.add(temp.keyAt(k));
    }
    equClass.add(temp3);
    }
    }
    else{
    // System.out.println(temp.toIntArrayList()+" 第 “+i+” ci");
    MySet temp2 = new MySet();
    for(int k = 0 ; k < temp.card() ; k++){
    temp2.add(temp.keyAt(k));
    }
    equClass.add(temp2);
    // System.out.println("#### “+temp2.toIntArrayList());
    temp.clear();
    temp.add(List.get(i));
    // System.out.println(”#### “+temp.toIntArrayList()+” “+List.get(i)+” "+i);
    if(i
    List.size()-1){
    MySet temp3 = new MySet();
    // System.out.println(”*** “+temp.toIntArrayList()+” “+List.get(i)+” "+i);
    temp3.add(temp.keyAt(0));
    equClass.add(temp3);
    }
    }
    }
    return equClass;
    }
    else{
    System.out.println(“您输入的属性不存在,不能为您求相应等价类”);
    ArrayList equClass = new ArrayList(0);
    return equClass;
    }
    }
    DecisionTable attributeReduct() throws CloneNotSupportedException
    {
    DecisionTable reduction = (DecisionTable)this.clone();
    DecisionTable temp = (DecisionTable)this.clone();
    ArrayList C = reduction.getConditionSet();
    Iterator it = C.iterator();
    MySet pos = this.POS();//原决策表中D的C正域

    	while(it.hasNext())
    	{
    		if(temp.removeConditionAttribute(it.next()).POS().isEqual(pos))
    		{
    			reduction = temp.clone();
    		}
    		else
    		{
    			temp = reduction.clone();
    		}
    	}
    	return reduction;
    }
    DecisionTable attributeReductByRely() throws CloneNotSupportedException
    {
    	DecisionTable reduction = this.clone();
    	DecisionTable tempDT;
    	double r = this.relyDegreeOfDToC();
    	
    	while(reduction.relyDegreeOfDToC() == r)
    	{
    		double sig = 1.0d;
    		int index = 0;
    		tempDT = reduction.clone();
    		ArrayList<Integer> condition = reduction.getConditionSet();
    		for(int i=0; i<condition.size(); i++)
    		{
    			if(reduction.sigOfAttribute(condition.get(i)) <sig)
    			{
    				sig = reduction.sigOfAttribute(condition.get(i));
    				index = i;
    			}
    		}
    		if(reduction.removeConditionAttribute(condition.get(index)).relyDegreeOfDToC() == r)
    		{
    			continue;
    		}
    		else
    		{
    			reduction = tempDT.clone();
    			break;
    		}
    	}
    	return reduction;
    }
    void print()
    {
    	Iterator<Integer> itAttribute;
    	itAttribute = this.getConditionSet().iterator();
    	while(itAttribute.hasNext())
    	{
    		System.out.print(itAttribute.next() + "  ");
    	}
    	System.out.print("\t->");
    	itAttribute = this.getDecisionSet().iterator();
    	while(itAttribute.hasNext())
    	{
    		System.out.print("  " + itAttribute.next());
    	}
    	System.out.println();
    }
    
    private ArrayList<Integer> conditionSet = new ArrayList<Integer>(0);
    private ArrayList<Integer> decisionSet = new ArrayList<Integer>(0);
    private ArrayList<MyElement> DT = new ArrayList<MyElement>(0);
    int serialNumberOfElement;
    

    }
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Iterator;
    public class MySet implements Cloneable
    {
    public MySet(){}
    //用数组初始化集合
    public MySet(float A[])
    {
    for(float e : A)
    {
    arrayList.add(e);
    }
    }
    public MySet(MySet s)
    {
    arrayList = s.arrayList;
    }
    public MySet(ArrayList al)
    {
    arrayList = al;
    }
    public MySet clone() throws CloneNotSupportedException
    {
    MySet cloned = new MySet();

    	Iterator<Float> itArrayList = this.arrayList.iterator();
    	while(itArrayList.hasNext())
    	{
    		cloned.arrayList.add(itArrayList.next());
    	}
    	
    	return cloned;
    }
    boolean isEmpty()
    {
    	return arrayList.isEmpty();
    }
    int card()
    {
    	return arrayList.size();
    }
    void clear()
    {
    	arrayList.clear();
    }
    int find(float a)
    {
    	for(int i=0; i<this.card();i++)
    	{
    		if(a == this.keyAt(i))
    		{
    			return i;
    		}
    	}
    	return -1;
    }
    float keyAt(int loc)
    {
    	return arrayList.get(loc);
    }
    void setKey(int loc,float val)
    {
    	arrayList.set(loc, val);
    }
    void sort()
    {
    	Collections.sort(arrayList);
    }
    void remove(float a)
    {
    	if(-1 != find(a))
    	{
    		ArrayList<Float> temp = new ArrayList<Float>(0);
    		for(int i=0;i<arrayList.size();i++)
    		{
    			if(arrayList.get(i) != a)
    			{
    				temp.add(arrayList.get(i));
    			}
    		}
    		arrayList = temp;
    	}
    }
    void add(float i)
    {
    	arrayList.add(i);
    }
    boolean belongTo(MySet s)
    {
    	for(float e : arrayList)
    	{
    		if(-1 == s.find(e))
    			return false;
    	}
    	return true;
    }
    boolean isEqual(MySet s)
    {
    	if(this.belongTo(s) && s.belongTo(this))
    	{
    		return true;
    	}
    	else
    	{
    		return false;
    	}
    }
    MySet sub(MySet s)
    {
    	if(s.belongTo(this))
    	{
    		MySet temp = new MySet(arrayList);
    		for(int i=0; i<s.card(); i++)
    		{
    			temp.remove(s.keyAt(i));
    		}
    		return temp;
    	}
    	else
    	{
    		System.out.println("参数中集合并非当前集的子集,不能进行该运算");
    		return null;
    	}
    }
    MySet union(MySet s)
    {
    	MySet temp = new MySet(arrayList);
    	for(int i=0;i<s.card();i++)
    		if(-1 == temp.find(s.keyAt(i)))
    		{
    			temp.add(s.keyAt(i));
    		}
    	return temp;
    }
    MySet interSect(MySet s)
    {
    	MySet temp = new MySet(arrayList);
    	for(int i=0; i<s.card();i++)
    		if(-1 == s.find(s.keyAt(i)))
    		{
    			temp.remove(s.keyAt(i));
    		}
    	MySet VOfA = temp.valueOfAttribute();
    	return VOfA;
    }
    MySet valueOfAttribute()
    {
    	MySet temp = new MySet();
    	for(int i=0; i<this.card();i++)
    	{
    		if(this.keyAt(i) != Integer.MAX_VALUE)
    		{
    			temp.add(this.keyAt(i));
    			for(int j=i+1; j<this.card();j++)
    			{
    				if(this.keyAt(i) == this.keyAt(j))
    				{
    					this.setKey(j, Integer.MAX_VALUE);
    				}
    			}
    		}
    		else
    			continue;
    	}
    	return temp;
    }
    ArrayList<Float> toIntArrayList()
    {
    	ArrayList<Float> temp = new ArrayList<Float>(0);
    	for(int i=0; i<this.card(); i++)
    	{
    		temp.add(this.keyAt(i));
    	}
    	return temp;
    }
    void print()
    {
    	int i=0;
    	System.out.print("{");
    	if(!arrayList.isEmpty())
    	{
    		System.out.print(arrayList.get(i));
    	}
    	i++;
    	for(; i<arrayList.size(); ++i)
    	{
    		System.out.print(","+arrayList.get(i));
    	}
    	System.out.print("}");
    }
    
    private ArrayList<Float> arrayList = new ArrayList<Float>(0);
    

    }

    上面最基本的三个类,根据最基本的3个类添加自己代码部分,实现功能。

    展开全文
  • 一种较先进的属性约简算法,算法介绍很详细,并且有实例,很具有实际参考意义
  • 决策粗糙集理论是经典粗糙集理论结合贝叶斯理论拓展而来。为在不完备区间值信息系统下研究决策粗糙集理论,首先提出属性相似度的概念,并基于属性相似度定义了双精度容差...最后提出属性约简算法并应用于目标识别实例
  • 粗糙集_属性约简

    2021-02-17 14:57:30
    其主要思想是在保持分类能力不变的前提下,通过知识约简,导出问题的决策或分类规则。从数学的角度看,粗糙集是研究集合的;从编程的角度看,粗糙集的研究对象是矩阵,只不过是一些特殊的矩阵;从人工智能的角度来看...


    咬定青山不放松,立根原在破岩中!
    ECRZ 记录美好事物。

    1.粗糙集简介

    粗糙集理论,是继概率论、模糊集、证据理论之后的有一个处理不确定性的数学工具。于1982年 波兰理工大学Z.pawlak教授提出用来研究不完整数据,不精确知识表达、学习、归纳等的一套理论。其主要思想是在保持分类能力不变的前提下,通过知识约简,导出问题的决策或分类规则。从数学的角度看,粗糙集是研究集合的;从编程的角度看,粗糙集的研究对象是矩阵,只不过是一些特殊的矩阵;从人工智能的角度来看,粗糙集研究的是决策表。

    2.粗糙集的价值

    粗糙集是用来处理不确定信息,可以通过一系列处理之后得出一个确定的结论.

    3.《粗糙集理论》例题1.11

    • 决策表构成部分

      • 决策表S=(U,A,V,f),A=C∪D,C∩D=∅,C为条件属性,D为决策属性(条件属性用来做筛选,决策属性用来做约简)

      • U:全集

      • A:属性集

      • V:属性值域范围

      • f:信息函数

      例如:由表1.4可得U={1,2,3,4,5},A={a,b,c,d},V={Va={0,1,2},Vb={0,1,2},Vc={0,1,2},Vd={0,1,2}},f如下所示

    • 表1.4(知识表达系统)

    Uabcd
    10120
    21200
    31010
    42101
    51102
    由表1.4可得
    U/a={1},{2,3,5},{4}
    U/b={3},{1,4,5},{2}
    U/c={2,4,5},{3},{1}
    U/d={1,3},{4},{2,5}
    U/A={1},{2},{3},{4},{5}
    1. 根据属性的值,进行分类,例如U/a,即a属性在全集中,属性值域为0的个体是{1},属性值域为1的个体是{2,3,5},属性值域为2的个体是{4},所以U/a={1},{2,3,5},{4}

    2. U/A这个是指A={a,b,c,d},A在U中的属性值域分类,相同的合并,不相同的单独存放。例如个体1,A的值域为 0120,与其他的四个并不同所以单独存放。

    • 表1.4.1(压缩后的知识表达系统)
    Uabcd
    10120
    21202
    31010
    42101
    51102

    表1.4.1是根据U/A得出得表达系统,因为个体没有相同得,所以最终压缩后的结果表1.4.1和之前的表1.4是一样的

    • 表1.5(区分矩阵)
    12345
    1Nulla,b,c,da,b,ca,c,da,c,d
    2a,b,c,dNullb,c,da,b,db
    3a,b,cb,c,dNulla,b,c,db,c,d
    4a,c,da,b,da,b,c,dNulla,d
    5a,c,dbb,c,da,dNull

    在表1.4中根据属性值域,找出不同的属性来。例如 1:2 = A1(a,b,c,d):A2(a,b,c,d) =A1(0,1,2,0):A2(1,2,0,2) ,其中1,2得属性元素值都不同,所以在表1.5中第二行第一列取值为(a,b,c,d)

    • 由表1.5可得,表1.5是一个区分矩阵所以还可以缩写为以下形式

    • 表1.5.1(区分矩阵)

    12345
    1Null
    2a,b,c,dNull
    3a,b,cb,c,dNull
    4a,c,da,b,da,b,c,dNull
    5a,c,dbb,c,da,dNull

    区分矩阵:也称对称矩阵,即矩阵数据是以对角线为基准对称起来。

    • 根据表1.5.1可得出以下区分函数:

    按照元素个体,一列一列的看,然后将每个个体合取起来.最终得到区分函数

    基本等值式
    重叠律: A ∨ A = A,A ∧ A = A
    交换律: A ∨ B = B ∨ A ,A ∧ B = B ∧ A
    结合律: (A ∨ B) ∨ C = A ∨ (B ∨ C), (A ∧ B) ∧ C = A ∧ (B ∧ C)
    吸收律: A ∨ (A ∧ B) = A,A ∧ (A ∨ B) = A
    分配律: A ∨ (B ∧ C) = (A ∨ B) ∧ (A ∨ C),A ∧ (B ∨ C) = (A ∧ B) ∨ (A ∧ C)
    • 区分函数的计算过程
    Δ =     (a ∨ b ∨ c ∨ d )( a ∨ b ∨ c )( a ∨ c ∨ d )( a ∨ c ∨ d )		Ⅰ
    
    ​		· (b ∨ c ∨ d )( a ∨ b ∨ d )( b )		Ⅱ
    
    ​		· (a ∨ b ∨ c ∨ d )( b ∨ c ∨ d )		Ⅲ
    
    ​		· (a ∨ d)		Ⅳ
    
    1.各个式子根据吸收律后可得   (注意此处将( a ∨ b ∨ c)看成一个整体,即t =  (a ∨ b ∨ c),q = ( a ∨ c ∨ d ) 之后可得出以下
    ( t ∨ d )  ( t ) ( q ) ( q ) = ( t ∨ d ) ∧ ( t ) ∧ ( q ) ∧ ( q ) = (t) ∧ (q)最终得出Ⅰ式)
    
    Ⅰ: ( a ∨ b ∨ c )( a ∨ c ∨ d ) 
    
    Ⅱ: b
    
    Ⅲ: ( b ∨ c ∨ d )
    
    Ⅳ:  (a ∨ d)
    
    2.联立ⅡⅢ(根据吸收律可得)
    
    Ⅰ: ( a ∨ b ∨ c )( a ∨ c ∨ d ) 
    
    Ⅱ: b
    
    Ⅳ:  (a ∨ d)
    
    3.联立ⅠⅡ(根据吸收律可得)
    
    Ⅰ: (b)( a ∨ c ∨ d ) 
    
    Ⅱ:  (a ∨ d)
    
    注意此处将(a ∨ d)看成一个整体,即t = (a ∨ d),之后可得出以下
    
    Ⅰ: (b)( t ∨ c ) 
    
    Ⅳ:  t
    
    4.联立ⅠⅣ(根据吸收律可得)
    
    Ⅰ: (b)(t) = (b)(a ∨ d) 
    
    5.最终结果为
    
    Ⅰ:ba∨bd
    
    6.最终得出{b,a}{b,d}为知识表达系统的约简,核为{b}
    
    1. (a ∨ b)(a ∨ b) = (a ∨ b) ∧ (a ∨ b)
    2. · = ∧ 例如:(a ∨ b) · (a ∨ b)=(a ∨ b) ∧ (a ∨ b)

    参考文献:
    [1]cowboy_wz.粗糙集理论[OL],2008

    展开全文
  • 基于粗糙集理论求信息系统和决策系统的属性约简,代码有详细注释,能运行,希望和大家一起交流。 基于粗糙集理论求信息系统和决策系统的属性约简,代码有详细注释,能运行,希望和大家一起交流。
  • 本文在介绍粗糙集理论的基础上,给出粗糙集 理论在数据挖掘中的应用,属性约简的启发式算法, 通过一个实例说明了算法的有效性
  • 目前我国企业效绩评价体系中存在指标冗余和指标关联两方面的缺陷,通过引入粗糙集理论与属性约简规则,结合16家沪市上市公司实例,在保证粗糙分类质量不变的情况下,对企业效绩评价指标属性约简。 结果表明,针对...
  • 邻域粗糙集是处理数据挖掘不确定性的有效方法之一。 在邻域粗集中,正域通常被用来反映特征子集的分类能力。然而,正域并不是分类精度的一个有效估计,因为它只考虑了包含一致性的决策邻域下近似信息而忽略了决策的...

      邻域粗糙集是处理数据挖掘不确定性的有效方法之一。 在邻域粗集中,正域通常被用来反映特征子集的分类能力。然而,正域并不是分类精度的一个有效估计,因为它只考虑了包含一致性的决策邻域下近似信息而忽略了决策的边界邻域上近似信息。针对目前邻域粗糙集模型中特征评估函数仅依据正域样本构造的缺点,通过引入决策自信息测度的概念,利用邻域粗糙集理论中的上下近似概念构造了决策变量的四种自信息不确定性测度,并详细讨论了其相关性质。基于第四种邻域自信息测度模型,构造特征评价函数——依赖度函数,并设计特征选择算法。
      本节知识点是我认为在本节学习中重要和应用实例中用到的知识点。

    1 邻域自信息及相关性质

      定义 1.1  测度 I ( x ) I(x) I(x) 是由 Claude Shannon 提出的,表示信号 x x x 的不确定性,称 I ( x ) I(x) I(x) x x x 的自信息,如果满足如下条件:
      (1) 非负性: I ( x ) ≥ 0 I(x) \geq 0 I(x)0;
      (2) 如果 p ( x ) → 0 p(x) \rightarrow 0 p(x)0,则有 I ( x ) → ∞ I(x) \rightarrow \infty I(x);
      (3) 如果 p ( x ) = 1 p(x)=1 p(x)=1,则有 I ( x ) = 0 I(x)=0 I(x)=0;
      (4) 严格单调性: 如果 p ( x ) > p ( y ) p(x)>p(y) p(x)>p(y),则有 I ( x ) < I ( y ) I(x)<I(y) I(x)<I(y).
      这里 p ( x ) p(x) p(x) x x x 出现的概率。

      定义 1.2  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A , R B δ (U, A, D), \quad U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, \quad B \subseteq A, \quad R_{B}^{\delta} (U,A,D),U/D={E1,E2,,Er},BA,RBδ 是由 B B B 诱导的 U U U 上的邻域关系。决策 d k d_{k} dk 的决策指标 d e c ( E k ) {dec}\left(E_{k}\right) dec(Ek),确信决策指标 c e r t B ( E k ) {cert}_{B}\left(E_{k}\right) certB(Ek) 和可能决策指标 p o s s B ( E k ) {poss}_{B}\left(E_{k}\right) possB(Ek) 定义如下:
    d e c ( E k ) = ∣ E k ∣ , c e r t B ( E k ) = ∣ R ‾ B δ ( E k ) ∣ , p o s s B ( E k ) = ∣ R ˉ B δ ( E k ) ∣ . \begin{aligned} &{dec}\left(E_{k}\right)=\left|E_{k}\right|, \\ &{cert}_{B}\left(E_{k}\right)=\left|\underline{R}_{B}^{\delta}\left(E_{k}\right)\right|, \\ &{poss}_{B}\left(E_{k}\right)=\left|\bar{R}_{B}^{\delta}\left(E_{k}\right)\right|. \end{aligned} dec(Ek)=Ek,certB(Ek)=RBδ(Ek),possB(Ek)=RˉBδ(Ek).  确信决策指标用决策的下近似的基数刻画,表示分类一致的样本数量。可能决策指标用决策的上近似的基数刻画,表示可能属于该决策类的样本数量。

    1.1 确信决策自信息

      定义 1.3  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, B \subseteq A (U,A,D),U/D={E1,E2,,Er},BA,确信决策的精度和粗糙度定义如下:
    μ B ( 1 ) ( E k ) = c e r t B ( E k ) d e c ( E k ) , v B ( 1 ) ( E k ) = 1 − c e r t B ( E k ) d e c ( E k ) . \begin{aligned} &\mu_{B}^{(1)}\left(E_{k}\right)=\frac{{cert}_{B}\left(E_{k}\right)}{{dec}\left(E_{k}\right)}, \\ &v_{B}^{(1)}\left(E_{k}\right)=1-\frac{{cert}_{B}\left(E_{k}\right)}{{dec}\left(E_{k}\right)}. \end{aligned} μB(1)(Ek)=dec(Ek)certB(Ek),vB(1)(Ek)=1dec(Ek)certB(Ek).  显然, 0 ≤ μ B ( 1 ) ( E k ) , v B ( 1 ) ( E k ) ≤ 1. μ B ( 1 ) ( E k ) 0 \leq \mu_{B}^{(1)}\left(E_{k}\right), \quad v_{B}^{(1)}\left(E_{k}\right) \leq 1 . \mu_{B}^{(1)}\left(E_{k}\right) 0μB(1)(Ek),vB(1)(Ek)1.μB(1)(Ek) 代表样本完全被分到决策 E k E_{k} Ek 的程度。 μ B ( 1 ) ( E k ) \mu_{B}^{(1)}\left(E_{k}\right) μB(1)(Ek) 是由特征子集 B B B 计算的确信决策 E k E_{k} Ek 出现的概率。 v B ( 1 ) ( E k ) v_{B}^{(1)}\left(E_{k}\right) vB(1)(Ek) 表示由特征子集 B B B 计算的等价类 E k E_{k} Ek 中的样本不一定属于 E k E_{k} Ek 的程度。 μ B ( 1 ) ( E k ) \mu_{B}^{(1)}\left(E_{k}\right) μB(1)(Ek) v B ( 1 ) ( E k ) v_{B}^{(1)}\left(E_{k}\right) vB(1)(Ek) 都能反应特征子集 B B B 的分类能力。

      定义 1.4  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, B \subseteq A (U,A,D),U/D={E1,E2,,Er},BA,确信决策自信息定义如下:
    I B ( 1 ) ( E k ) = − v B ( 1 ) ( E k ) log ⁡ μ B ( 1 ) ( E k ) . I_{B}^{(1)}\left(E_{k}\right)=-v_{B}^{(1)}\left(E_{k}\right) \log \mu_{B}^{(1)}\left(E_{k}\right). IB(1)(Ek)=vB(1)(Ek)logμB(1)(Ek).

      定义 1.5  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, B \subseteq A (U,A,D),U/D={E1,E2,,Er},BA, 决策系统的确信决策自信息定义如下:
    I B ( 1 ) ( D ) = ∑ k = 1 r I B ( 1 ) ( E k ) . I_{B}^{(1)}(D)=\sum_{k=1}^{r} I_{B}^{(1)}\left(E_{k}\right). IB(1)(D)=k=1rIB(1)(Ek).

      定义 1.6  给定决策表 ( U , A , D ) , B ⊆ A (U, A, D), B \subseteq A (U,A,D),BA, 称 B B B 是一个决策系统的确信决策约简,如果满足如下条件:
      (1) I B ( 1 ) ( D ) = I A ( 1 ) ( D ) I_{B}^{(1)}(D)=I_{A}^{(1)}(D) IB(1)(D)=IA(1)(D);
      (2) I B − a i ( 1 ) ( D ) ≠ I B ( 1 ) ( D ) I_{B-{a_{i}}}^{(1)}(D) \neq I_{B}^{(1)}(D) IBai(1)(D)=IB(1)(D), 对于任意 a i ∈ B a_{i} \in B aiB.

    1.2 可能决策自信息

      定义 1.7  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, B \subseteq A (U,A,D),U/D={E1,E2,,Er},BA,可能决策的精度和粗糙度定义如下:
    μ B ( 2 ) ( E k ) = d e c ( E k ) p o s s B ( E k ) , v B ( 2 ) ( E k ) = 1 − d e c ( E k ) p o s s B ( E k ) . \begin{aligned} &\mu_{B}^{(2)}\left(E_{k}\right)=\frac{{dec}\left(E_{k}\right)}{p o s s_{B}\left(E_{k}\right)} , \\ &v_{B}^{(2)}\left(E_{k}\right)=1-\frac{{dec}\left(E_{k}\right)}{{poss}_{B}\left(E_{k}\right)} . \end{aligned} μB(2)(Ek)=possB(Ek)dec(Ek),vB(2)(Ek)=1possB(Ek)dec(Ek).  显然, 0 < μ B ( 2 ) ( E k ) ≤ 1 , 0 ≤ v B ( 2 ) ( E k ) < 1. μ B ( 2 ) ( E k ) 0<\mu_{B}^{(2)}\left(E_{k}\right) \leq 1,0 \leq v_{B}^{(2)}\left(E_{k}\right)<1 . \mu_{B}^{(2)}\left(E_{k}\right) 0<μB(2)(Ek)1,0vB(2)(Ek)<1.μB(2)(Ek) 描述决策 E k E_{k} Ek B B B 计算的上近似的程度,也可以看作是可能决策 E k E_{k} Ek 的概率。 v B ( 2 ) ( E k ) v_{B}^{(2)}\left(E_{k}\right) vB(2)(Ek) 描述对象在决策类 E k E_{k} Ek 范围之外但在决策类 E k E_{k} Ek 上近似中的程度.

      定义 1.8  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, B \subseteq A (U,A,D),U/D={E1,E2,,Er},BA, 可能决策自信息定义如下:
    I B ( 2 ) ( E k ) = − v B ( 2 ) ( E k ) log ⁡ μ B ( 2 ) ( E k ) . I_{B}^{(2)}\left(E_{k}\right)=-v_{B}^{(2)}\left(E_{k}\right) \log \mu_{B}^{(2)}\left(E_{k}\right). IB(2)(Ek)=vB(2)(Ek)logμB(2)(Ek).

      定义 1.9  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, B \subseteq A (U,A,D),U/D={E1,E2,,Er},BA, 系统的可能决策自信息定义如下:
    I B ( 2 ) ( D ) = ∑ k = 1 r I B ( 2 ) ( E k ) . I_{B}^{(2)}(D)=\sum_{k=1}^{r} I_{B}^{(2)}\left(E_{k}\right). IB(2)(D)=k=1rIB(2)(Ek).

    1.3 有效决策自信息

      定义 1.10  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, \quad B \subseteq A (U,A,D),U/D={E1,E2,,Er},BA, 有效决策自信息定义如下:
    I B ( 3 ) ( E k ) = I B ( 1 ) ( E k ) + I B ( 2 ) ( E k ) . I_{B}^{(3)}\left(E_{k}\right)=I_{B}^{(1)}\left(E_{k}\right)+I_{B}^{(2)}\left(E_{k}\right). IB(3)(Ek)=IB(1)(Ek)+IB(2)(Ek).

      定义 1.11  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, \quad B \subseteq A (U,A,D),U/D={E1,E2,,Er},BA, 决策系统的有效决策自信息定义如下:
    I B ( 3 ) ( D ) = ∑ k = 1 r I B ( 3 ) ( E k ) . I_{B}^{(3)}(D)=\sum_{k=1}^{r} I_{B}^{(3)}\left(E_{k}\right). IB(3)(D)=k=1rIB(3)(Ek).

    1.4 相对决策自信息

      定义 1.12  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, B \subseteq A (U,A,D),U/D={E1,E2,,Er},BA, 相对决策的精度和粗糙度定义如下:
    μ B ( 3 ) ( E k ) = c e r t B ( E k ) p o s s B ( E k ) , v B ( 3 ) ( E k ) = 1 − c e r t B ( E k ) p o s s B ( E k ) . \begin{aligned} &\mu_{B}^{(3)}\left(E_{k}\right)=\frac{{cert}_{B}\left(E_{k}\right)}{{poss}_{B}\left(E_{k}\right)}, \\ &v_{B}^{(3)}\left(E_{k}\right)=1-\frac{{cert}_{B}\left(E_{k}\right)}{{poss}_{B}\left(E_{k}\right)}. \end{aligned} μB(3)(Ek)=possB(Ek)certB(Ek),vB(3)(Ek)=1possB(Ek)certB(Ek).  显然, 0 ≤ μ B ( 3 ) ( E k ) , v B ( 3 ) ( E k ) ≤ 1. μ B ( 3 ) ( E k ) 0 \leq \mu_{B}^{(3)}\left(E_{k}\right), v_{B}^{(3)}\left(E_{k}\right) \leq 1 . \mu_{B}^{(3)}\left(E_{k}\right) 0μB(3)(Ek),vB(3)(Ek)1.μB(3)(Ek) 描述了确信决策和可能决策的对象基数的比例。 v B ( 3 ) ( E k ) v_{B}^{(3)}\left(E_{k}\right) vB(3)(Ek) 描述了对象在可能决策中但没有在确信决策中的比例。

      定义 1.13  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, B \subseteq A (U,A,D),U/D={E1,E2,,Er},BA,相对决策自信息的定义为:
    I B ( 4 ) ( E k ) = − v B ( 3 ) ( E k ) log ⁡ μ B ( 3 ) ( E k ) . I_{B}^{(4)}\left(E_{k}\right)=-v_{B}^{(3)}\left(E_{k}\right) \log \mu_{B}^{(3)}\left(E_{k}\right). IB(4)(Ek)=vB(3)(Ek)logμB(3)(Ek).

      定义 1.14  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, \quad B \subseteq A (U,A,D),U/D={E1,E2,,Er},BA, 决策信息系统的相对决策自信息定义如下:
    I B ( 4 ) ( D ) = ∑ k = 1 r I B ( 4 ) ( E k ) . I_{B}^{(4)}(D)=\sum_{k=1}^{r} I_{B}^{(4)}\left(E_{k}\right). IB(4)(D)=k=1rIB(4)(Ek).

      定义 1.15  给定决策表 ( U , A , D ) , U / D = { E 1 , E 2 , ⋯   , E r } , B ⊆ A , B (U, A, D), U / D=\left\{E_{1}, E_{2}, \cdots, E_{r}\right\}, B \subseteq A, B (U,A,D),U/D={E1,E2,,Er},BA,B 被称为 A A A 关 于 D D D 的相对决策约简, 当且仅当:
      (1) I B ( 4 ) ( D ) = I A ( 4 ) ( D ) I_{B}^{(4)}(D)=I_{A}^{(4)}(D) IB(4)(D)=IA(4)(D);
      (2) I B − a i ( 4 ) ( D ) ≠ I B ( 4 ) ( D ) I_{B-{a_{i}}}^{(4)}(D) \neq I_{B}^{(4)}(D) IBai(4)(D)=IB(4)(D), 对于任意 a i ∈ B a_{i} \in B aiB.

    2 应用举例

      演示四种领域自信息的计算过程。直接贴图片吧,嘻嘻嘻…
      表 3-1 为一个决策系统 ( U , A , D ) (U, A, D) (U,A,D), 这里 U = { x 1 , x 2 , x 3 , x 4 , x 5 , x 6 } U=\left\{x_{1}, x_{2}, x_{3}, x_{4}, x_{5}, x_{6}\right\} U={x1,x2,x3,x4,x5,x6} 是 对象集 A = { a 1 , a 2 , a 3 } A=\left\{a_{1}, a_{2}, a_{3}\right\} A={a1,a2,a3} 是属性集, D D D 是决策属性。根据决策属性 D D D 将论域划分成两个等价类 E 1 = { x 1 , x 2 , x 3 } E_{1}=\left\{x_{1}, x_{2}, x_{3}\right\} E1={x1,x2,x3} E 2 = { x 4 , x 5 , x 6 } E_{2}=\left\{x_{4}, x_{5}, x_{6}\right\} E2={x4,x5,x6}

      首先将决策表标准化到 [ 0 , 1 ] [0,1] [0,1] 区间, 结果如表 3.2 所示。
    在这里插入图片描述
      在本例题中,设定邻域粒度 δ=0.4,计算所有属性子集的关系矩阵,结果如下所示:
    在这里插入图片描述在这里插入图片描述
      根据关系矩阵,计算两个决策类 E 1 E_{1} E1 E 2 E_{2} E2确信决策指标可能决策指标。结果如表 3-3 和表 3-4 所示。
    在这里插入图片描述
      分别计算出确信决策,可能决策和相关决策的精度,如表 3-5 所示以及三种决策的粗糙度如表 3-6 所示。(涉及到对数运算,精度不能为0,取0.1111。Why? 我也不知道额…)
    在这里插入图片描述
      表 3-7 显示了由确信决策自信息可能决策自信息有效邻域自信息和每个决策类的相对邻域自信息计算的结果。
    在这里插入图片描述
      表 3-8 表示系统的四种邻域自信息计算结果。
    在这里插入图片描述
      从表 3-8 中不难发现,随着特征数的增加,每种邻域的自信息都在单调地减少。通过比较有效决策自信息和相对决策自信息,可以发现相对决策自信息减少得更为显著。这意味着相对决策自信息具有更大的收敛速度,更容易受到特征分类能力的影响,因此说明相对决策自信息更适合刻画特征子集的区分能力。
      考虑到相对决策自信息不仅可以减少误分类的可能性,而且具有较好的收敛效果,故用其作为特征评价函数来度量特征子集的分类能力。

    3 小结

      心若有所向往,何惧道阻且长!共勉!

    参考文献

    [1]黄洋. 基于自信息测度的特征选择方法研究[D].渤海大学,2019.

    展开全文
  • 其次,从F-粗糙集及并行约简出发,并结合模糊粗糙集的属性重要度,提出了F-模糊粗糙集及其约简,为增量式或动态模糊决策表的属性约简提供了一种有效的方法;最后,通过实例验证了F-模糊粗糙集及其约简的可行性.
  • 粗糙集属性约简

    千次阅读 2008-04-01 19:00:00
    粗糙集属性约简规则如下,数据如下所示:a1 b1 c1 d1a1 b2 c1 d2a2 b3 c2 d3a1 b2 c3 d3a1 b1 c3 d3a1 b3 c1 d3a1 b4 c1 d1最基本的:即,第一列属性去掉后,随后余下的属性进行查询时,相同...

    粗糙集的属性约简规则如下,数据如下所示:

    a1 b1 c1 d1
    a1 b2 c1 d2
    a2 b3 c2 d3
    a1 b2 c3 d3
    a1 b1 c3 d3
    a1 b3 c1 d3
    a1 b4 c1 d1

    最基本的:即,第一列属性去掉后,随后余下的属性进行查询时,相同的条件属性的决策属性没有冲突,则说明去掉第一列并没有不一致的数据产生,则说明第一列可去掉,如此循环,直到所有的决策属性都被判断完毕

    说是很简单,但是实现起来细节问题很多,思路如下:

    从第一个属性开始循环,直至最后一个条件属性,用余下的条件属性进行查询,分如下情况:

    if(在DB中无相同的条件属性) 则说明根本不可能产生不一致数据的机会,此属性可去掉

    if(有相同的条件属性)则找出相应的决策属性,判断是否相等{

        if(决策属性相等) 则说明相同的条件属性并没有产生不同的决策属性,可去掉

        if(决策属性不相等) 则说明相同的条件属性产生了不同的决策,不可去掉(此属性起关键作用)

    }

    问题:

    判断一个Vector中的重复元素,并计算重复次数,并判断重复次数是否过半数以上,如下方法:

     public boolean getSymbol(Vector<String> decisionProperty) {
      boolean isFlag = false;
      int length = decisionProperty.size();
      Vector<String> distinctDecProperty = new Vector<String>();
      Vector<Boolean> flag = new Vector<Boolean>();
      int i = 0;
      while (i < length) {
       flag.add(true);
       i++;
      }
      for (int j = 0; j < length; j++) {
       i = j + 1;
       int n = 1;
       while (i < length) {
        if (flag.get(i) == true) {
         if (decisionProperty.get(j).equals(decisionProperty.get(i))) {
          flag.set(i, false);
          n++;
         } else {
          i++;
         }
        } else {
         i++;
        }
       }
       if (flag.get(j) == true) {
        distinctDecProperty.add(decisionProperty.get(j));
       }
       if (n >= length / 2) {
        isFlag = true;
       }
      }
      if (distinctDecProperty.size() == decisionProperty.size()){
       isFlag = false;
      }
      System.out.println(distinctDecProperty + "  " + decisionProperty);
      return isFlag;
     }

    以上代码为实现此功能的原程序,并不单单仅实现了此功能

    需要注意的是,多设置了一个VECTOR型flag,用来标志重复的元素,若为flase,则说明已经和之前比较过的数据重复了,可不用比较。这样,用空间来换取了一定的时间复杂度。

    还有distinctDecProperty是最后的没有重复的元素的VECTOR,注意语句的位置

    今天的时间,一些花在resultset的结果如何判断为空上,还有是VECTOR的去重,属性约简思路的整理,和程序细节上,感觉仅仅写算法比用程序真正实现容易多了,:(

    有的时候做多了,自己的脑子就浆糊了,抱怨下,:(

    可能还有没有想到的,想起了再补充


     

    展开全文
  • 定义了基于广义多粒度粗糙集属性约简,研究了约简的一些基本性质,给出matlab计算的过程,并给出计算实例。定义了信息系统的严格协调、软不协调性、粒度协调、粒度不协调,定义了广义多粒度下约简、粒度约简、(下...
  • 给出了一种新的粗糙集知识约简方法,即结合粗糙集理论的依赖度定义,先给出知识约简转化定理,然后运用一种改进型蚁群算法,采用局部和全局搜索相结合的方法,对知识表达系统进行约简。同时,在适值函数中引入罚函数...
  • 提出一种基于粗糙集的改进的约简算法和决策表预处理方法,在对决策表进行预处理后,以核为基础,用改进的加权属性重要度方法选择非核属性,增加反向删除操作。该算法能够充分反映专家经验知识,保证得到一个Pawlak...
  • 对 Skowron可辨识矩阵方法进行分析,应用反例说明基于Skowron可辨识矩阵方法对不相容决策表属性约简 中存在一定的局限性。...实例分析表明该 算法能够有效地对不相容决策表进行属性约简,且具有较好的约简效果。
  • 粗糙集理论和数据挖掘的关系 Rough set理论和数据挖掘关系密切,它能为数据挖掘提供新的方法和工具,且具有以下特点: 首先,数据挖掘研究的对象多为关系型数据库。关系表可以看作为Rough Set理论中的决策表,这给...
  • 属性约简MATLAB算 法有实例有讲解 粗糙集属性约简 题目SARS诊断 注这是我学粗糙集时老师给的作业 U 干 咳 呼 吸 困 难 血 液 检 测 高 烧 38 度 X 射 线 浓 痰 血 细 胞 多 寒 战 肌 肉 酸 痛 乏 力 胸 膜 痛 头 痛 ...
  • 目前粗糙集的研究局限于有限集,且现有的邻域粗糙集属性约简算法中属性重要性度量方式单一。针对邻域粗糙集存在的问题,提出了基于无限集的邻域近似条件熵模型。该模型以邻域近似条件熵下的属性重要度为启发条件,...
  • 基于幂图的属性约简

    2021-01-14 11:38:21
    针对粗糙集理论中基于差别矩阵的属性约简方法存在的不足, 提出一种基于幂图的属性约简算法. 首先通过修改样本决策属性值将不相容决策表转化为简化的相容决策表; 然后将样本对概念与幂图概念相结合, 将基于修正差别...
  • 与以往粗糙集约简模型相比,为提高约简精确性,提出性能为O(|P||U|)的等价类划分方法和性能为O(|P||U|)的属性重要性度量方法.同时给出了相关定理和等价命题,论证了传统决策约简模型和决策分辨约简模型的一致性.并基于...
  • 该模型由于同时考虑了条件属性和决策属性对决策表的分类能力,它是一种考虑较周全的属性约简模型。为设计高效的属性约简算法,首先引入简化差别矩阵, 同时给出了基于该简化差别矩阵的属性约简定义,并证明该定义与...
  • 基于粗糙集理论,提出了加注系统风险预测模型:首先,应用属性约简算法,将加注系统风险源权重的确定问题转化为粗糙集理论中属性重要性的评价问题,通过计算得到加注系统各风险源的权重,从而使加注系统风险源权重的确定更...
  • 2006 年 6 月 系统工程理论与实践 第 6 期 文章编号 :100026788(2006)060101207基于简化差别矩阵的属性约简算法 高学东 ,丁 军 (北京科技大学管理学院 ,北京 100083) 摘要 : 为降低基于修正差别矩阵的属性约简算法的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 675
精华内容 270
关键字:

粗糙集属性约简实例