best first search

ASSearch                 搜索算法类

ASEvaluation              特征结果集评价算法类。该类有接口接受样本输入

AttributeEvaluation        单个特征的评价类

AttributeSetEvaluation    特征集的评价类

AttributeSelection          特征选择类， 接受ASSearch与ASEvaluation作为输入

AttributeTransformer     数据转换类



Best First Search：

m_bestMerit， 记录评价最高的得分

m_cacheSize， 已评价了多少组不同的特征； lookup记录已评价属性集及其评价分的集合

m_searchDirection， 搜索方向：正向，后向，双向

m_starting， 初始结果集

m_totalEvals， 已评价次数>= m_cacheSize



1)    初始化

如果已给出初始结果集，则此轮结果集就是初始结果集；若未给出初始结果集且为双向搜索，则此轮结果集就是所有的属性集。

计算此轮结果集的评价得分， 将该结果集与得分放入已查数据中； 将该结果集放入待搜索队列中





2)    迭代搜索

迭代退出条件是， 如果连续多次扩展得到的结果集都没有比当前最好的更优，则退出，Stale < m_max_stale；  或者待扩展队列已为空。

2.0）取得待扩展队列头

2.1）根据搜索方向扩展该属性集得到新的属性集：顺序扫描每个属性，如果未处理过该属性， 则将该属性增加到待扩展集中。（如果是backward搜索， 则是将该属性从待扩展集中移除；后面类同）

2.2）如果该新的属性集未曾处理过， 则计算其评价分、将其增加到lookup中； 将该属性集加入到待扩展集中。 判断此次扩展是否比当前最好的更优、更优则记录相关信息。

2.3）恢复到迭代2.0）状态时的属性集，迭代2.1）中扫描下一个未曾处理的属性

Notes：如果是双向搜索时，则步骤2中，都是在步骤2.0）的基础之上先正向对所有属性做测试；然后逆向对所有属性做测试。就是把双向分为了先正向后逆向两个完全分开的过程。



3）步骤2退出时， 得到了最佳属性集合

    while (stale < m_maxStale) 
	{
		added = false;
		if (m_searchDirection == SELECTION_BIDIRECTIONAL) 
		{
			// bi-directional search
			done = 2;
			sd = SELECTION_FORWARD;
		} 
		else 
		{
			done = 1;
		}

		// finished search?
		if (bfList.size() == 0) 
		{
			stale = m_maxStale;
			break;
		}

		// copy the attribute set at the head of the list
		tl = bfList.getLinkAt(0);
		temp_group = (BitSet)(tl.getData()[0]);
		temp_group = (BitSet)temp_group.clone();
		// remove the head of the list
		bfList.removeLinkAt(0);
		// count the number of bits set (attributes)
		//TODO 计算temp_group中已处理过的属性个数 size

		do 
		{
			for (i = 0; i < m_numAttribs; i++) {
				//测试第i个属性是否已处理过。 z==true时表示未处理过、待处理
				if (sd == SELECTION_FORWARD) {
					z = ((i != m_classIndex) && (!temp_group.get(i)));
				} else {
					z = ((i != m_classIndex) && (temp_group.get(i)));
				}
      
				if (z) 
				{
					// set the bit (attribute to add/delete)
					// 如果待处理， 则对正向搜索而言就是增加到属性集中； 逆向搜索就是从属性集中删除
					if (sd == SELECTION_FORWARD) {
						temp_group.set(i);
						size++;
					} else {
						temp_group.clear(i);
						size--;
					}

					/* if this subset has been seen before, then it is already 
   					in the list (or has been fully expanded) */
					//如果该扩展后的属性集已见过，则取出其评价分； 未见过则处理：
					tt = (BitSet)temp_group.clone();
					hashC = tt.toString();
					if (lookup.containsKey(hashC) == false) {
						merit = ASEvaluator.evaluateSubset(temp_group);
						m_totalEvals++;
  					} else {
						merit = ((Double)lookup.get(hashC)).doubleValue();
						cacheHits++;  
					}

					// insert this one in the list。 增加到待扩展集中
					Object[] add = new Object[1];
					add[0] = tt.clone();
					bfList.addToList(add, merit);


					// is this better than the best?
					if (sd == SELECTION_FORWARD) {
						z = ((merit - best_merit) > 0.00001);
					} else 	if (merit == best_merit) {
						z = (size < best_size);
					} else {
						z = (merit >  best_merit);
					} 
				}

				if (z) //比当前最佳更好， 则记录相关信息
				{
					added = true;
					stale = 0;
					best_merit = merit;
					best_size = size;
					best_group = (BitSet)(temp_group.clone());
				}

				// unset this addition(deletion)
				//重置当前选择， 以便进行下一个属性测试
				if (sd == SELECTION_FORWARD) {
					temp_group.clear(i);
					size--;
				} else {
					temp_group.set(i);
					size++;
				}
			}////end for

			if (done == 2) {
				sd = SELECTION_BACKWARD;
			}

			done--;
		} while (done > 0); ///end do

		/* if we haven't added a new attribute subset then full expansion 
 		of this node hasen't resulted in anything better */
		if (!added) {
			stale++;
		}
	}///end while

    m_bestMerit = best_merit;
    return  attributeList(best_group);