pairedttester.java

来自「wekaUT是 university texas austin 开发的基于wek」· Java 代码 · 共 1,963 行 · 第 1/5 页

    for (int j = 0; j < getNumResultsets(); j++) {
      if (j != baseResultset) {
        label = new StringBuffer(Utils.padLeft("(" + (j + 1) + ") "
                                               + getResultsetName(j), resultsetLength));
        titles.append(label).append(' ');
        for (int i = 0; i < label.length(); i++) {
          separator.append('-');
        }
        separator.append('-');
      }
    }
    result.append(titles).append('\n').append(separator).append('\n');
    
    // Iterate over datasets
    int [] win = new int [getNumResultsets()];
    int [] loss = new int [getNumResultsets()];
    int [] tie = new int [getNumResultsets()];
    StringBuffer skipped = new StringBuffer("");
    for (int i = 0; i < getNumDatasets(); i++) {
      // Print the name of the dataset
      String datasetName = 
        templateString(m_DatasetSpecifiers.specifier(i));
      try {
        PairedStats pairedStats = 
          calculateStatistics(m_DatasetSpecifiers.specifier(i), 
                              baseResultset, baseResultset,
                              comparisonColumn);
        datasetName = Utils.padRight(datasetName, datasetLength);
        result.append(datasetName);
        result.append(Utils.padLeft('('
                                    + Utils.doubleToString(pairedStats.count,
                                                           0)
                                    + ')', 5)).append(' ');
        if (!m_ShowStdDevs) {
          result.append(Utils.doubleToString(pairedStats.xStats.mean,
                                             resultsetLength - 2, m_Precision)).
            append(" | ");
        } else {
          result.append(Utils.doubleToString(pairedStats.xStats.mean,
                                             meanWidth, m_Precision));
          if (Double.isInfinite(pairedStats.xStats.stdDev)) {
            result.append('(' + Utils.padRight("Inf", meanWidthStdDev)
                          +')').append(" | ");
          } else {
            result.append('('+Utils.doubleToString(pairedStats.xStats.stdDev,
                                                   meanWidthStdDev, m_Precision)
                          +')').append(" | ");
          }
        }
        // Iterate over the resultsets
        for (int j = 0; j < getNumResultsets(); j++) {
          if (j != baseResultset) {
            try {
              pairedStats = 
                calculateStatistics(m_DatasetSpecifiers.specifier(i), 
                                    baseResultset, j, comparisonColumn);
              char sigChar = ' ';
              if (pairedStats.differencesSignificance < 0) {
                sigChar = 'v';
                win[j]++;
              } else if (pairedStats.differencesSignificance > 0) {
                sigChar = '*';
                loss[j]++;
              } else {
                tie[j]++;
              }
              if (!m_ShowStdDevs) {
                result.append(Utils.doubleToString(pairedStats.yStats.mean,
                                                   resultsetLength - 2,
                                                   m_Precision)).append(' ')
                  .append(sigChar).append(' ');
              } else {
                result.append(Utils.doubleToString(pairedStats.yStats.mean,
                                                   meanWidth,
                                                   m_Precision));
                if (Double.isInfinite(pairedStats.yStats.stdDev)) {
                  result.append('(' 
                                + Utils.padRight("Inf", meanWidthStdDev)
                                +')');
                } else {
                  result.append('('+Utils.doubleToString(pairedStats.
                                                         yStats.stdDev, 
                                                         meanWidthStdDev,
                                                         m_Precision)+')');
                }
                result.append(' ').append(sigChar).append(' ');
              }
            } catch (Exception ex) {
              ex.printStackTrace();
              result.append(Utils.padLeft("", resultsetLength + 1));
            }
          }
        }
        result.append('\n');
      } catch (Exception ex) {
        ex.printStackTrace();
        skipped.append(datasetName).append(' ');
      }
    }
    result.append(separator).append('\n');
    result.append(Utils.padLeft("(v/ /*)", datasetLength + 4 +
                                resultsetLength)).append(" | ");
    for (int j = 0; j < getNumResultsets(); j++) {
      if (j != baseResultset) {
        result.append(Utils.padLeft("(" + win[j] + '/' + tie[j]
                                    + '/' + loss[j] + ')',
                                    resultsetLength)).append(' ');
      }
    }
    result.append('\n');
    if (!skipped.equals("")) {
      result.append("Skipped: ").append(skipped).append('\n');
    }
    return result.toString();
  }
		



    //=============== BEGIN EDIT melville ===============

    /**
     * Generates comparison tables across learning curves
     *
     * @param baseResultset the index of the base resultset
     * @param comparisonColumn the index of the column to compare over
     * @param maxWidthMean width for the mean
     * @param maxWidthStdDev width for the standard deviation
     * @return the comparison table string
     */
    private String multiResultsetFullLearningPlainText(int baseResultset,
						       int comparisonColumn,
						       int maxWidthMean,
						       int maxWidthStdDev) {
	
	StringBuffer result = new StringBuffer(1000);
	//Compute column widths for pretty printing
	int datasetLength = 20;
	int meanWidth = maxWidthMean;//account for the decimal point and decimal digits
	if(m_Precision>0) meanWidth += (1 + m_Precision); //account for the decimal point and decimal digits
	int resultsetLength = 2*meanWidth + 6;
	int stdWidth = 0;
	int maxPointWidth = 6;
	if (m_ShowStdDevs) {
	    stdWidth = maxWidthStdDev + 1 + m_Precision;
	    resultsetLength += 2*stdWidth + 4;
	}
	
	//Find maximum point width - assuming the points are in order
	maxPointWidth = (int) (Math.log(m_Points[m_Points.length-1])/Math.log(10)) + 1;
	if(maxPointWidth<6) maxPointWidth=6;
	
	Vector datasetNames = new Vector();//store names of dataset
	HashMap specMap = new HashMap();//maps dataset:point pair to a unique specifier
	
	for (int i = 0; i < getNumDatasets(); i++) {
	    Instance spec = m_DatasetSpecifiers.specifier(i);
	    String dataName = spec.toString(m_DatasetKeyColumns[0]);
	    String point = spec.toString(m_DatasetKeyColumns[1]);
	    if(!datasetNames.contains(dataName)){
		datasetNames.add(dataName);
	    }
	    specMap.put(dataName+":"+point, spec);
	}
		
	StringBuffer titles;
	for (int j = 0; j < getNumResultsets(); j++) {//For each system comparison
	    //Generate a different table comparing pts across the learning curve with the base system
	    
	    if (j == baseResultset) continue;
	    
	    //Display title
	    titles = new StringBuffer();
	    titles.append("Comparing "+Utils.padLeft("(" + (j + 1)+ ") "+ getResultsetName(j),
						     15)+" to "+
			  Utils.padRight("(" + (baseResultset + 1)+ ") "+ getResultsetName(baseResultset),
					 15));
	    result.append(titles.toString()).append("\n\n");
	    
	    //Display table headings
	    int numPts = m_Points.length;
	    int []c_win = new int[numPts];//column totals to each point on the learning curve
	    int []c_loss = new int[numPts];
	    int []c_tie = new int[numPts];
	    result.append("Dataset\n");
	    if(m_Fraction)
		result.append(Utils.padLeft("% Points",datasetLength));
	    else
		result.append(Utils.padLeft("Points",datasetLength));
	    
	    for(int pts=0; pts<numPts; pts++){
		if(m_Fraction)
		    result.append(Utils.padLeft(Utils.doubleToString(m_Points[pts]*100,maxPointWidth,2)+"    ",resultsetLength));
		else
		    result.append(Utils.padLeft(Utils.doubleToString(m_Points[pts],maxPointWidth,2)+"    ",resultsetLength));
	    }
	    result.append("\n");
	    result.append(Utils.padLeft("",datasetLength));
	    for(int pts=0; pts<numPts; pts++)
		for(int k=0; k<resultsetLength; k++)
		    result.append("-");
	    result.append("\n");
	    
	    for(int dataIndex=0; dataIndex<datasetNames.size(); dataIndex++){//for each dataset
		int r_win=0, r_loss=0, r_tie=0;//row totals for each dataset
		
		result.append(Utils.padRight((String)datasetNames.get(dataIndex), datasetLength));
		
		for(int ptIndex=0; ptIndex<m_Points.length; ptIndex++){//for each point on the curve
		    String key = datasetNames.get(dataIndex)+":"+(new Double(m_Points[ptIndex]));
		    Object obj = specMap.get(key);
		    if(!m_Fraction && obj==null){ 
			key = datasetNames.get(dataIndex)+":"+(new Integer((int) m_Points[ptIndex]));
			obj = specMap.get(key);
		    }
		    if(obj!=null){//if the point was recorded
			Instance specifier = (Instance) obj;
			try {
			    PairedStats pairedStats = 
				calculateStatistics(specifier, 
						    baseResultset, j, comparisonColumn);
			    
			    char sigChar = ' ';
			    if (pairedStats.differencesSignificance < 0) {
				sigChar = 'v';
				r_win++;
				c_win[ptIndex]++;
			    } else if (pairedStats.differencesSignificance > 0) {
				sigChar = '*';
				r_loss++;
				c_loss[ptIndex]++;
			    } else {
				r_tie++;
				c_tie[ptIndex]++;
			    }
			    result.append(Utils.padLeft("",4));
			    result.append(sigChar).append(Utils.doubleToString(pairedStats.yStats.mean,
									       meanWidth,
									       m_Precision));
			    
			    if (m_ShowStdDevs) {
				if (Double.isInfinite(pairedStats.xStats.stdDev)) {
				    result.append('(' + Utils.padRight("Inf", stdWidth)
						  +')');
				} else {
				    result.append('('+Utils.doubleToString(pairedStats.yStats.stdDev,
									   stdWidth,m_Precision)
						  +')');
				}
			    }
			    
			    result.append('/');
			    
			    pairedStats = 
				calculateStatistics(specifier, 
						    baseResultset, baseResultset,
						    comparisonColumn);
			    
			    result.append(Utils.doubleToString(pairedStats.xStats.mean,
							       meanWidth, m_Precision));
			    if (m_ShowStdDevs) {
				if (Double.isInfinite(pairedStats.xStats.stdDev)) {
				    result.append('(' + Utils.padRight("Inf", stdWidth)
						  +')');
				} else {
				    result.append('('+Utils.doubleToString(pairedStats.xStats.stdDev,
									   stdWidth,m_Precision)
						  +')');
				}
			    }
			}catch (Exception ex) {
			    ex.printStackTrace();
			}
		    }else{//if the point was not tested print spaces
			result.append(Utils.padLeft("",resultsetLength));
		    }
		}
		result.append("    (" + r_win + '/' + r_tie
			      + '/' + r_loss + ")\n");
	    }
	    
	    //Display column totals of win/tie/loss counts
	    result.append(Utils.padLeft("(v/ /*)",datasetLength));
	    int win=0,tie=0,loss=0;
	    for(int ptIndex=0; ptIndex<m_Points.length; ptIndex++){//for each point on the curve
		win += c_win[ptIndex];
		tie += c_tie[ptIndex];
		loss += c_loss[ptIndex];
		result.append(Utils.padLeft("(" + c_win[ptIndex] + '/' + c_tie[ptIndex]
					    + '/' + c_loss[ptIndex] + ")    ",
					    resultsetLength));
		
	    }
	    result.append("    (" +win + '/' +tie
			  + '/' + loss + ")\n\n\n");
	}
	
	return result.toString();
    }
    //=============== END EDIT melville ===============



    //=============== BEGIN EDIT melville ===============
    /**
     * Generates learning curves for one result set i.e. only results from one system
     *
     * @param baseResultset the index of the base resultset
     * @param comparisonColumn the index of the column to compare over
     * @param maxWidthMean width for the mean
     * @param maxWidthStdDev width for the standard deviation
     * @return the comparison table string
     */
    private String oneResultsetFullLearningPlainText(int baseResultset,
						     int comparisonColumn,
						     int maxWidthMean,
						     int maxWidthStdDev) {
	
	StringBuffer result = new StringBuffer(1000);
	//Compute column widths for pretty printing
	int datasetLength = 20;
	int meanWidth = maxWidthMean;
	if(m_Precision>0) meanWidth += (1 + m_Precision); //account for the decimal point and decimal digits
	int resultsetLength = meanWidth + 4;
	int stdWidth = 0;
	int maxPointWidth = 6;
	if (m_ShowStdDevs) {
	    stdWidth = maxWidthStdDev + 1 + m_Precision;
	    resultsetLength += stdWidth + 2;
	}
	
	//Find maximum point width - assuming the points are in order
	maxPointWidth = (int) (Math.log(m_Points[m_Points.length-1])/Math.log(10)) + 1;
	if(maxPointWidth<6) maxPointWidth=6;
	
	Vector datasetNames = new Vector();//store names of dataset
	HashMap specMap = new HashMap();//maps dataset:point pair to a unique specifier
	
	for (int i = 0; i < getNumDatasets(); i++) {
	    Instance spec = m_DatasetSpecifiers.specifier(i);
	    String dataName = spec.toString(m_DatasetKeyColumns[0]);
	    String point = spec.toString(m_DatasetKeyColumns[1]);
	    if(!datasetNames.contains(dataName)){
		datasetNames.add(dataName);
	    }
	    specMap.put(dataName+":"+point, spec);
	}
		
	StringBuffer titles;
	//Display title
	titles = new StringBuffer();
	
	titles.append("Learning curve results for "+Utils.padLeft("(" + (baseResultset + 1)+ ") "+
								  getResultsetName(baseResultset),15));
	
	result.append(titles.toString()).append("\n\n");
	
	//Display table headings
	int numPts = m_Points.length;
	result.append("Dataset\n");
	if(m_Fraction)
	    result.append(Utils.padLeft("% Points",datasetLength));
	else
	    result.append(Utils.padLeft("Points",datasetLength));
	
	for(int pts=0; pts<numPts; pts++){
	    if(m_Fraction)
		result.append(Utils.padLeft(Utils.doubleToString(m_Points[pts]*100,maxPointWidth,2),resultsetLength));
	    else
		result.append(Utils.padLeft(Utils.doubleToString(m_Points[pts],maxPointWidth,2),resultsetLength));
	}
	result.append("\n");
	result.append(Utils.padLeft("",datasetLength));
	for(int pts=0; pts<numPts; pts++)
	    for(int k=0; k<resultsetLength; k++)
		result.append("-");
	result.append("\n");
	
	for(int dataIndex=0; dataIndex<datasetNames.size(); dataIndex++){//for each dataset
	    result.append(Utils.padRight((String)datasetNames.get(dataIndex), datasetLength));
	    
	    for(int ptIndex=0; ptIndex<m_Points.length; ptIndex++){//for each point on the curve
		String key = datasetNames.get(dataIndex)+":"+(new Double(m_Points[ptIndex]));
		Object obj = specMap.get(key);
		if(!m_Fraction && obj==null){ 
		    key = datasetNames.get(dataIndex)+":"+(new Integer((int) m_Points[ptIndex]));
		    obj = specMap.get(key);
		}
		if(obj!=null){//if the point was recorded
		    Instance specifier = (Instance) obj;
		    try {
			PairedStats pairedStats = calculateStatistics(specifier, 
								      baseResultset, baseResultset,