boundaryvisualizer.java

一个数据挖掘软件ALPHAMINERR的整个过程的JAVA版源代码

    colTwo.add(tempPanel, BorderLayout.NORTH);

    JPanel startPanel = new JPanel();
    startPanel.setBorder(BorderFactory.
			 createTitledBorder("Plotting"));
    startPanel.setLayout(new BorderLayout());
    startPanel.add(m_startBut, BorderLayout.CENTER);
    startPanel.add(m_plotTrainingData, BorderLayout.WEST);

    colTwo.add(startPanel, BorderLayout.SOUTH);

    m_controlPanel.add(colOne, BorderLayout.WEST);
    m_controlPanel.add(colTwo, BorderLayout.CENTER);
    JPanel classHolder = new JPanel();
    classHolder.setBorder(BorderFactory.createTitledBorder("Class color"));
    classHolder.add(m_classPanel);
    m_controlPanel.add(classHolder, BorderLayout.SOUTH);

    add(m_controlPanel, BorderLayout.NORTH);

    m_boundaryPanel = new BoundaryPanel(m_plotAreaWidth, m_plotAreaHeight);
    m_numberOfSamplesFromEachRegion = m_boundaryPanel.getNumSamplesPerRegion();
    m_regionSamplesText.setText(""+m_numberOfSamplesFromEachRegion+"  ");
    m_generatorSamplesBase = (int)m_boundaryPanel.getGeneratorSamplesBase();
    m_generatorSamplesText.setText(""+m_generatorSamplesBase+"  ");

    m_dataGenerator = new KDDataGenerator();
    m_kernelBandwidth = m_dataGenerator.getKernelBandwidth();
    m_kernelBandwidthText.setText(""+m_kernelBandwidth+"  ");
    m_boundaryPanel.setDataGenerator(m_dataGenerator);
    add(m_boundaryPanel, BorderLayout.CENTER);

    m_xAxisPanel = new AxisPanel(false);
    add(m_xAxisPanel, BorderLayout.SOUTH);
    m_yAxisPanel = new AxisPanel(true);
    add(m_yAxisPanel, BorderLayout.WEST);

    m_startBut.setEnabled(false);
    m_startBut.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent e) {
	  if (m_startBut.getText().equals("Start")) {
	    if (m_trainingInstances != null && m_classifier != null) {
	      try {
		int tempSamples = m_numberOfSamplesFromEachRegion;
		try {
		  tempSamples = 
		    Integer.parseInt(m_regionSamplesText.getText().trim());
		} catch (Exception ex) {
		  m_regionSamplesText.setText(""+tempSamples);
		}
		m_numberOfSamplesFromEachRegion = tempSamples;
		m_boundaryPanel.
		  setNumSamplesPerRegion(tempSamples);

		tempSamples = m_generatorSamplesBase;
		try {
		  tempSamples = 
		    Integer.parseInt(m_generatorSamplesText.getText().trim());
		} catch (Exception ex) {
		  m_generatorSamplesText.setText(""+tempSamples);
		}
		m_generatorSamplesBase = tempSamples;
		m_boundaryPanel.setGeneratorSamplesBase((double)tempSamples);

		tempSamples = m_kernelBandwidth;
		try {
		  tempSamples = 
		    Integer.parseInt(m_kernelBandwidthText.getText().trim());
		} catch (Exception ex) {
		  m_kernelBandwidthText.setText(""+tempSamples);
		}
		m_kernelBandwidth = tempSamples;
		m_dataGenerator.setKernelBandwidth(tempSamples);

		m_trainingInstances.
		  setClassIndex(m_classAttBox.getSelectedIndex());
		m_boundaryPanel.setClassifier(m_classifier);
		m_boundaryPanel.setTrainingData(m_trainingInstances);
		m_boundaryPanel.setXAttribute(m_xIndex);
		m_boundaryPanel.setYAttribute(m_yIndex);
		m_boundaryPanel.
		  setPlotTrainingData(m_plotTrainingData.isSelected());
		m_boundaryPanel.start();
		m_startBut.setText("Stop");
		setControlEnabledStatus(false);
	      } catch (Exception ex) {
		ex.printStackTrace();
	      }
	    }
	  } else {
	    m_boundaryPanel.stopPlotting();
	    m_startBut.setText("Start");
	    setControlEnabledStatus(true);
	  }
	}
      });

    m_boundaryPanel.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent e) {
	  m_startBut.setText("Start");
	  setControlEnabledStatus(true);
	}
      });

    m_classPanel.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent e) {

	  try {
	    // save color vector to a file
	    FastVector colors = m_boundaryPanel.getColors();
	    FileOutputStream fos = new FileOutputStream("colors.ser");
	    ObjectOutputStream oos = new ObjectOutputStream(fos);
	    oos.writeObject(colors);
	    oos.flush();
	    oos.close();
	  } catch (Exception ex) {}

	  m_boundaryPanel.replot();
	}
      });
  }

  /**
   * Set the enabled status of the controls
   *
   * @param status a <code>boolean</code> value
   */
  private void setControlEnabledStatus(boolean status) {
    m_classAttBox.setEnabled(status);
    m_xAttBox.setEnabled(status);
    m_yAttBox.setEnabled(status);
    m_regionSamplesText.setEnabled(status);
    m_generatorSamplesText.setEnabled(status);
    m_kernelBandwidthText.setEnabled(status);
    m_plotTrainingData.setEnabled(status);
  }

  /**
   * Set a classifier to use
   *
   * @param newClassifier the classifier to use
   * @exception Exception if an error occurs
   */
  public void setClassifier(Classifier newClassifier) throws Exception {

    m_classifier = newClassifier;
  }

  private void computeBounds() {
    String xName = (String)m_xAttBox.getSelectedItem();
    if (xName == null) {
      return;
    }
    xName = Utils.removeSubstring(xName, "X: ");
    xName = Utils.removeSubstring(xName, " (Num)");
    String yName = (String)m_yAttBox.getSelectedItem();
    yName = Utils.removeSubstring(yName, "Y: ");
    yName = Utils.removeSubstring(yName, " (Num)");

    m_xIndex = -1;
    m_yIndex = -1;
    for (int i = 0; i < m_trainingInstances.numAttributes(); i++) {
      if (m_trainingInstances.attribute(i).name().equals(xName)) {
	m_xIndex = i;
      } 
      if (m_trainingInstances.attribute(i).name().equals(yName)) {
	m_yIndex = i;
      }
    }

    if (m_xIndex != -1 && m_yIndex != -1) {
      // find the min and max values
      m_minX = Double.MAX_VALUE;
      m_minY = Double.MAX_VALUE;
      m_maxX = Double.MIN_VALUE;
      m_maxY = Double.MIN_VALUE;

      for (int i = 0; i < m_trainingInstances.numInstances(); i++) {
	Instance inst = m_trainingInstances.instance(i);
	if (!inst.isMissing(m_xIndex)) {
	  double value = inst.value(m_xIndex);
	  if (value < m_minX) {
	    m_minX = value;
	  }
	  if (value > m_maxX) {
	    m_maxX = value;
	  }
	}
	if (!inst.isMissing(m_yIndex)) {
	  double value = inst.value(m_yIndex);
	  if (value < m_minY) {
	    m_minY = value;
	  }
	  if (value > m_maxY) {
	    m_maxY = value;
	  }
	}
      }
    }
  }

  /**
   * Get the training instances
   *
   * @return the training instances
   */
  public Instances getInstances() {
    return m_trainingInstances;
  }

  /**
   * Set the training instances
   *
   * @param inst the instances to use
   */
  public void setInstances(Instances inst) throws Exception {
    if (inst.numAttributes() < 3) {
      throw new Exception("Not enough attributes in the data to visualize!");
    }
    m_trainingInstances = inst;
    m_classPanel.setInstances(m_trainingInstances);
    // setup combo boxes
    String [] classAttNames = new String [m_trainingInstances.numAttributes()];
    final Vector xAttNames = new Vector();
    Vector yAttNames = new Vector();

    for (int i = 0; i < m_trainingInstances.numAttributes(); i++) {
      classAttNames[i] = m_trainingInstances.attribute(i).name();
      if (m_trainingInstances.attribute(i).isNominal()) {
	classAttNames[i] += " (Nom)";
      } else {
	classAttNames[i] += " (Num)";
      }
      if (m_trainingInstances.attribute(i).isNumeric()) {
	xAttNames.addElement("X: "+classAttNames[i]);
	yAttNames.addElement("Y: "+classAttNames[i]);
      }
    }

    m_classAttBox.setModel(new DefaultComboBoxModel(classAttNames));
    m_xAttBox.setModel(new DefaultComboBoxModel(xAttNames));
    m_yAttBox.setModel(new DefaultComboBoxModel(yAttNames));
    if (xAttNames.size() > 1) {
      m_yAttBox.setSelectedIndex(1);
    }

    m_classAttBox.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent e) {
	  configureForClassAttribute();
	}
      });

    m_xAttBox.addItemListener(new ItemListener() {
	public void itemStateChanged(ItemEvent e) {
	  if (e.getStateChange() == ItemEvent.SELECTED) {
	    if (xAttNames.size() > 1) {
	      if (m_xAttBox.getSelectedIndex() == 
		  m_yAttBox.getSelectedIndex()) {
		m_xAttBox.setSelectedIndex((m_xAttBox.getSelectedIndex() + 1) %
					   xAttNames.size());
	      }
	    }
	    computeBounds();
	    repaint();
	  }
	}
      });

    m_yAttBox.addItemListener(new ItemListener() {
	public void itemStateChanged(ItemEvent e) {
	  if (e.getStateChange() == ItemEvent.SELECTED) {
	    if (xAttNames.size() > 1) {
	      if (m_yAttBox.getSelectedIndex() == 
		  m_xAttBox.getSelectedIndex()) {
		m_yAttBox.setSelectedIndex((m_yAttBox.getSelectedIndex() + 1) %
					   xAttNames.size());
	      }
	    }
	    computeBounds();
	    repaint();
	  }
	}
      });
    computeBounds();
    revalidate();
    repaint();
  }
  
  /**
   * Set up the class values combo boxes
   */
  private void configureForClassAttribute() {
    int classIndex = m_classAttBox.getSelectedIndex();
    if (classIndex >= 0) {
      // see if this is a nominal attribute
      if (!m_trainingInstances.attribute(classIndex).isNominal()) {
	m_startBut.setEnabled(false);
      } else {
	m_startBut.setEnabled(true);
	// set up class colours
	FastVector colors = new FastVector();
	for (int i = 0; i < 
	       m_trainingInstances.attribute(classIndex).numValues(); i++) {
	  colors.addElement(BoundaryPanel.
		    DEFAULT_COLORS[i % BoundaryPanel.DEFAULT_COLORS.length]);
	  m_classPanel.setColours(colors);	  
	  m_boundaryPanel.setColors(colors);
	}
      }
    }
  }

  /**
   * Main method for testing this class
   *
   * @param args a <code>String[]</code> value
   */
  public static void main(String [] args) {

    try {
      if (args.length < 2) {
	System.err.println("Usage : BoundaryPanel <dataset> <classifier "
			   +"[classifier options]>");
	System.exit(1);
      }
      final javax.swing.JFrame jf = 
	new javax.swing.JFrame("Weka classification boundary visualizer");
      jf.getContentPane().setLayout(new BorderLayout());
      BoundaryVisualizer bv = new BoundaryVisualizer();
      jf.getContentPane().add(bv, BorderLayout.CENTER);
      jf.setSize(bv.getMinimumSize());
      jf.addWindowListener(new java.awt.event.WindowAdapter() {
	  public void windowClosing(java.awt.event.WindowEvent e) {
	    jf.dispose();
	    System.exit(0);
	  }
	});

      jf.pack();
      jf.setVisible(true);
      jf.setResizable(false);
      Dimension t = jf.getSize();

      System.err.println("Loading instances from : "+args[0]);
      java.io.Reader r = new java.io.BufferedReader(
			 new java.io.FileReader(args[0]));
      Instances i = new Instances(r);
      bv.setInstances(i);
      String [] argsR = null;
      if (args.length > 2) {
	argsR = new String [args.length-2];
	for (int j = 2; j < args.length; j++) {
	  argsR[j-2] = args[j];
	}
      }
      Classifier c = Classifier.forName(args[1], argsR);
      bv.setClassifier(c);
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }
}