ccpanel.java

著名的神经网络工具箱

    pGeneral.add( tMaxOutErr );
    gbc.gridx = 0;
    gbc.gridy++;

    gbc.gridwidth = 2;
    gbl.setConstraints( cbCovNErr, gbc );
    pGeneral.add( cbCovNErr );

    gbc.gridy++;
    gbl.setConstraints( cbCache, gbc );
    pGeneral.add( cbCache );

    gbc.gridy++;
    gbl.setConstraints(cbPrune, gbc);
    pGeneral.add(cbPrune);
    cbPrune.addActionListener(this);

    gbc.gridwidth = 1;
    gbc.gridy++;
    gbl.setConstraints( lMini, gbc );
    pGeneral.add( lMini );
    gbc.gridx = 1;
    gbl.setConstraints( ncbMini, gbc );
    pGeneral.add( ncbMini );
  }

  private void buildMod(){
    pMod = new JPanel();

    JLabel lMod = new JLabel("Modification: ");
    ncbMod = new NamedComboBox();
    ncbMod.addItems( functions.modi );
    ncbMod.addActionListener( this );

    lMod.setToolTipText("Optional algorithm modification");
    ncbMod.setToolTipText("Optional algorithm modification");

    JPanel pParam = new JPanel();
    pParam.setLayout( null );
    pParam.setBorder( BorderFactory.createTitledBorder("Parameters") );
    Insets in = pParam.getInsets();

  // parameter panel:{
    Dimension
      dLabel = new Dimension( functions.getMaxLabelWidth(),
                              ( new JLabel("N") ).getPreferredSize().height ),
      dTextF = ( new JTextField( 8 ) ).getPreferredSize(),
      pref   = new Dimension();

    int i, h, v, dx = 2 * ( insets.left + insets.right) + dLabel.width + dTextF.width;

    pref.height = ( param.length + 1 )/2 *
      ( insets.top + Math.max( dTextF.height, dLabel.height ) + insets.bottom )
      + in.top + in.bottom;
    pref.width = 2 * dx + in.left + in.right ;
    pParam.setPreferredSize( pref );

    for( i=0; i<param.length; i++ ){
      h = i%2; v = i/2;
      lParam[i] = new JLabel("noName");
      lParam[i].setSize( lParam[i].getPreferredSize() );
      lParam[i].setLocation(
        in.left + insets.left + h * dx,
        in.top + insets.top + v * ( dTextF.height + insets.top + insets.bottom )
      );
      pParam.add( lParam[i] );

      tParam[i] = new JTextField( 8 );
      tParam[i].setSize( tParam[i].getPreferredSize() );
      tParam[i].setLocation(
        in.left + 2 * insets.left + dLabel.width + insets.right + h * dx,
        in.top + insets.top + v * ( dTextF.height + insets.top + insets.bottom )
      );
      pParam.add( tParam[i] );
    }
  // }

    GridBagLayout gbl = new GridBagLayout();
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.insets = insets;
    gbc.weightx = gbc.weighty = 0.5;
    gbc.fill = gbc.HORIZONTAL;
    pMod.setLayout( gbl );

    gbc.gridx = gbc.gridy = 0;
    gbl.setConstraints( lMod, gbc );
    pMod.add( lMod );

    gbc.gridx = 1;
    gbl.setConstraints( ncbMod, gbc );
    pMod.add( ncbMod );

    gbc.gridwidth = 2;
    gbc.gridx = 0;
    gbc.gridy = 1;
    gbl.setConstraints( pParam, gbc );
    pMod.add( pParam );
  }

  private void buildCand(){
    pCand = new JPanel();
    JLabel lMinCovCh = new JLabel("Minimum covariance change: "),
           lCandPat = new JLabel("Candidate patience: "),
           lMaxCovUp = new JLabel("Max. no. of covariance updates: "),
           lMaxCandNo = new JLabel("Max. no. of candidate units: "),
           lActFn = new JLabel("Activation function: ");

    tMinCovCh = new JTextField( 6 );
    tCandPat = new JTextField();
    tMaxCovUp = new JTextField();
    tMaxCandNo = new JTextField();
    ncbActFn = new NamedComboBox();
    ncbActFn.addItems( functions.actFn );

    lMinCovCh.setToolTipText("Fraction of old covariance");
    tMinCovCh.setToolTipText("Fraction of old covariance");
    lCandPat.setToolTipText("Steps to wait with evaluating covariance change");
    tCandPat.setToolTipText("Steps to wait with evaluating covariance change");
    lMaxCovUp.setToolTipText("Max. updates before accepting a new cascade");
    tMaxCovUp.setToolTipText("Max. updates before accepting a new cascade");
    lMaxCandNo.setToolTipText("Canidate pool size");
    tMaxCandNo.setToolTipText("Canidate pool size");
    lActFn.setToolTipText("Activation function for the candidates");
    ncbActFn.setToolTipText("Activation function for the candidates");

    GridBagLayout gbl = new GridBagLayout();
    GridBagConstraints gbc = new GridBagConstraints();
    pCand.setLayout( gbl );
    gbc.fill = gbc.HORIZONTAL;
    gbc.insets = insets;
    // gbc.weightx = gbc.weighty = 0.5;

    gbc.gridx = 0;
    gbc.gridy = 0;
    gbl.setConstraints( lMinCovCh , gbc );
    pCand.add( lMinCovCh );

    gbc.gridx = 1;
    gbl.setConstraints( tMinCovCh , gbc );
    pCand.add( tMinCovCh );

    gbc.gridx = 0;
    gbc.gridy = 1;
    gbl.setConstraints( lCandPat , gbc );
    pCand.add( lCandPat );

    gbc.gridx = 1;
    gbl.setConstraints( tCandPat , gbc );
    pCand.add( tCandPat );

    gbc.gridx = 0;
    gbc.gridy = 2;
    gbl.setConstraints( lMaxCovUp , gbc );
    pCand.add( lMaxCovUp );

    gbc.gridx = 1;
    gbl.setConstraints( tMaxCovUp , gbc );
    pCand.add( tMaxCovUp );

    gbc.gridx = 0;
    gbc.gridy = 3;
    gbl.setConstraints( lMaxCandNo , gbc );
    pCand.add( lMaxCandNo );

    gbc.gridx = 1;
    gbl.setConstraints( tMaxCandNo , gbc );
    pCand.add( tMaxCandNo );

    gbc.gridx = 0;
    gbc.gridy = 4;
    gbl.setConstraints( lActFn , gbc );
    pCand.add( lActFn );

    gbc.gridx = 1;
    gbl.setConstraints( ncbActFn , gbc );
    pCand.add( ncbActFn );
  }

  private void buildOut(){
    pOut = new JPanel();
    JLabel lErrCh = new JLabel("Error change: "),
           lOutPat = new JLabel("Output patience: "),
           lMaxEpochs = new JLabel("Max. no. of epochs: ");

    tErrCh = new JTextField( 8 );
    tOutPat = new JTextField( 8 );
    tMaxEpochs = new JTextField( 8 );

    lErrCh.setToolTipText("Fraction of old error");
    tErrCh.setToolTipText("Fraction of old error");
    lOutPat.setToolTipText("Steps to wait with evaluating error change");
    tOutPat.setToolTipText("Steps to wait with evaluating error change");
    lMaxEpochs.setToolTipText("Max. epochs before accepting a new cascade");
    tMaxEpochs.setToolTipText("Max. epochs before accepting a new cascade");

    GridBagLayout gbl = new GridBagLayout();
    GridBagConstraints gbc = new GridBagConstraints();
    pOut.setLayout( gbl );
    gbc.insets = insets;
    // gbc.weightx = gbc.weighty = 0.5;

    gbc.gridx = 0;
    gbc.gridy = 0;
    gbc.anchor = gbc.EAST;
    gbl.setConstraints( lErrCh, gbc );
    pOut.add( lErrCh );

    gbc.gridx = 1;
    gbc.anchor = gbc.CENTER;
    gbl.setConstraints( tErrCh, gbc );
    pOut.add( tErrCh );

    gbc.gridx = 0;
    gbc.gridy = 1;
    gbc.anchor = gbc.EAST;
    gbl.setConstraints( lOutPat, gbc );
    pOut.add( lOutPat );

    gbc.gridx = 1;
    gbc.anchor = gbc.CENTER;
    gbl.setConstraints( tOutPat, gbc );
    pOut.add( tOutPat );

    gbc.gridx = 0;
    gbc.gridy = 2;
    gbc.anchor = gbc.EAST;
    gbl.setConstraints( lMaxEpochs, gbc );
    pOut.add( lMaxEpochs );

    gbc.gridx = 1;
    gbc.anchor = gbc.CENTER;
    gbl.setConstraints( tMaxEpochs, gbc );
    pOut.add( tMaxEpochs );
  }

  private void buildInit(){
    pInit = new JPanel();

    JLabel lMinInit = new JLabel("min "),
           lMaxInit = new JLabel("max ");

    tMinInit = new JTextField(6);
    tMinInit.setToolTipText("Minimum activation value");
    lMinInit.setToolTipText("Minimum activation value");
    tMaxInit = new JTextField(6);
    tMaxInit.setToolTipText("Maximum activation value");
    lMaxInit.setToolTipText("Maximum activation value");

    bInit = new JButton("Init");
    bInit.addActionListener( this );
    bInit.setToolTipText("Delete hidden layers and initialize network");

    GridBagLayout gbl = new GridBagLayout();
    pInit.setLayout( gbl );
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.insets = insets;
    gbc.weightx = gbc.weighty = 0.5;

    gbc.gridx = gbc.gridy = 0;
    gbc.anchor = gbc.EAST;
    gbl.setConstraints(lMinInit, gbc );
    pInit.add(lMinInit);
    gbc.gridx = 1;
    gbc.anchor = gbc.CENTER;
    gbl.setConstraints( tMinInit, gbc );
    pInit.add( tMinInit );
    gbc.gridx = 2;

    gbc.anchor = gbc.EAST;
    gbl.setConstraints(lMaxInit, gbc);
    pInit.add(lMaxInit, gbc);
    gbc.gridx = 3;
    gbc.anchor = gbc.CENTER;
    gbl.setConstraints( tMaxInit, gbc );
    pInit.add( tMaxInit );
    gbc.gridy++;

    gbc.anchor = gbc.CENTER;
    gbl.setConstraints( bInit, gbc );
    pInit.add( bInit );
  }

  private void buildLearn(){
    pLearn = new JPanel();

    lLearnParam = new JLabel[5];
    tCascades = new JTextField( 8 );
    ncbLearnFn = new NamedComboBox();
    ncbLearnFn.addItems( functions.learn );
    ncbLearnFn.addActionListener( this );
    bLearn = new JButton("Learn");
    bLearn.addActionListener( this );

    JLabel lCascades = new JLabel("Cascades: "),
           lLearnFn = new JLabel("Learning function: ");

    lCascades.setToolTipText("Maximum number of cascades (hidden layers)");
    tCascades.setToolTipText("Maximum number of cascades (hidden layers)");
    lLearnFn.setToolTipText("Subordinate function for training the candidates");
    ncbLearnFn.setToolTipText("Subordinate function for training the candidates");

    JPanel pParam = new JPanel();
    pParam.setLayout( null );
    pParam.setBorder( BorderFactory.createTitledBorder("Parameters") );
    Insets in = pParam.getInsets();

    // parameter panel:{
    Dimension
      dLabel = new Dimension( functions.getMaxLabelWidth(),
                              ( new JLabel("N") ).getPreferredSize().height ),
      dTextF = ( new JTextField( 8 ) ).getPreferredSize(),
      pref   = new Dimension();

    int i, h, v, dx = 2 * ( insets.left + insets.right) + dLabel.width + dTextF.width,
        maxParamNo = learnParam.length;

    lLearnParam = new JLabel[ maxParamNo ];
    tLearnParam = new JTextField[ maxParamNo ];

    pref.height = ( maxParamNo + 1 )/2 *
      ( insets.top + Math.max( dTextF.height, dLabel.height ) + insets.bottom )
      + in.top + in.bottom;
    pref.width = 2 * dx + in.left + in.right ;
    pParam.setPreferredSize( pref );

    for( i=0; i<maxParamNo; i++ ){
      h = i%2; v = i/2;
      lLearnParam[i] = new JLabel("noName");
      lLearnParam[i].setSize( lLearnParam[i].getPreferredSize() );
      lLearnParam[i].setLocation(
        in.left + insets.left + h * dx,
        in.top + insets.top + v * ( dTextF.height + insets.top + insets.bottom )
      );
      pParam.add( lLearnParam[i] );

      tLearnParam[i] = new JTextField( 8 );
      tLearnParam[i].setSize( tLearnParam[i].getPreferredSize() );
      tLearnParam[i].setLocation(
        in.left + 2 * insets.left + dLabel.width + insets.right + h * dx,
        in.top + insets.top + v * ( dTextF.height + insets.top + insets.bottom )
      );
      pParam.add( tLearnParam[i] );
    }
  // }


    GridBagLayout gbl = new GridBagLayout();
    pLearn.setLayout( gbl );
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.insets = insets;
    gbc.weightx = gbc.weighty = 0.5;

    gbc.gridx = gbc.gridy = 0;
    gbl.setConstraints( lLearnFn, gbc );
    pLearn.add( lLearnFn );

    gbc.gridx = 1;
    gbl.setConstraints( ncbLearnFn, gbc );
    pLearn.add( ncbLearnFn );

    gbc.gridy = 1;
    gbc.gridx = 0;
    gbc.gridwidth = 3;
    gbc.fill = gbc.HORIZONTAL;
    gbl.setConstraints( pParam, gbc );
    pLearn.add( pParam );

    gbc.gridy = 2;
    gbc.gridwidth = 1;
    gbc.anchor = gbc.EAST;
    gbc.fill = gbc.NONE;
    gbl.setConstraints( lCascades, gbc );
    pLearn.add( lCascades );

    gbc.gridx = 1;
    gbc.anchor = gbc.WEST;
    gbl.setConstraints( tCascades, gbc );
    pLearn.add( tCascades );

    gbc.gridx = 2;
    gbc.anchor = gbc.EAST;
    gbl.setConstraints( bLearn, gbc );
    pLearn.add( bLearn );
  }

  /**
   * this method contains the default values and sets them to the text fields
   */
  private void setDefaultValues(){
    maxOutErr = 0.2;
    tMaxOutErr.setText( String.valueOf( maxOutErr ) );
    minCovCh = 0.04;
    tMinCovCh.setText( String.valueOf( minCovCh ) );
    candPat = 25;
    tCandPat.setText( String.valueOf( candPat ) );
    maxCovUp = 200;
    tMaxCovUp.setText( String.valueOf( maxCovUp ) );
    maxCandNo = 8;
    tMaxCandNo.setText( String.valueOf( maxCandNo ) );
    errCh = 0.01;
    tErrCh.setText( String.valueOf( errCh ) );
    outPat = 50;
    tOutPat.setText( String.valueOf( outPat ) );
    maxEpochs = 200;
    tMaxEpochs.setText( String.valueOf( maxEpochs ) );
    minInit = -1;
    tMinInit.setText( String.valueOf( minInit ) );
    maxInit = 1;
    tMaxInit.setText( String.valueOf( maxInit ) );
    learnParam = new double[]{0.2, 0, 0, 0, 0};
    for( int i=0; i<5; i++ )
      tLearnParam[i].setText( String.valueOf( learnParam[i] ) );
    cascades = 10;
    tCascades.setText( String.valueOf( cascades ) );
  }

  private void showException( String text ){
    snns.showException( new Exception( text ), this );
  }
}