EXPERIMENTmO              package:FKBL              R Documentation

_M_a_k_e_s _a_n _E_X_P_E_R_I_M_E_N_T _w_i_t_h _t_h_e _M_u_l_t_i_o_b_j_e_c_t_i_v_e _a_l_g_o_r_i_t_h_m_s

_D_e_s_c_r_i_p_t_i_o_n:

     This eases the realization of an experiment with the
     Multiobjective algorithms, ErrorSize and MOGA. This function is
     exactly to EXPERIENT, but in the multiobjective real. If
     EXPERIMENT eases experiments with the 11 single objetive
     algorithms, EXPERIMENTmO does the same with the 2 multiobjective
     algorithms. As a multobjective algorithm

_U_s_a_g_e:

      
     EXPERIMENTmO(data, chunks=10, numPart=5, 
             genM=100, crossM=0.8, mutaM=0.1, kB=NULL, P=NULL,
             genMo=50, crossMo=0.8, mutaMo=0.01, popuMo=20, eliteMo=5,
             genS=100, crossS=0.5, mutaS=0.01, kS=0.01, popuS=20)

_A_r_g_u_m_e_n_t_s:

     Takes the train data, the number of chunks, the number of
     divisions  of a partition, the number of generations for the
     Michigan algorithm, the cross and mutation probability of the
     Michigan algorithm, the initial kB,  the vector of Partitions. For
     MOGA there are: the number of generations, the cross and mutation
     probability, the size of the initial population and the size of
     the elite population. And for ErrorSize there are: the number of
     generations, the cross probability, the mutation probability, the
     weight for the size and the initial population.

     As ErrorSize and MOGA are tweaking algorithms, they need an
     initial knowledge base (kB), if none is provided, the Michigan
     algorithm is used to create an appropriate default kB. The same
     happens with the vector of partitions (P), if none is provided
     "getPart" is used to generate one. A set of default parameters are
     provided to serve as an example to the user. The only parameter
     with no default is the problem dataset.

    data: The problem dataset.

  chunks: The number of chunks for getTrain and getTest.

 numPart: The number of divisions for the getPart algorithm.

    genM: The number of Michigan generations.

  crossM: The cross probability up to 1, at Michigan.

   mutaM: The mutation probability up to 1, at Michigan.

      kB: the initial kB, if none is provided, the Michigan algorithm
          is used.

       P: the vector of Partitions, if none is provided, one is created
          automatically.

   genMo: The number of generations for the MOGA.

 crossMo: The crossing probability for the MOGA.

  mutaMo: The mutations probability for the MOGA.

  popuMo: The initial population for the MOGA.

 eliteMo: The elite size of the MOGA.

    genS: The number of ErrorSize generations.

  crossS: The cross probability up to 1, at ErrorSize.

   mutaS: The mutation probability up to 1, at ErrorSize.

      kS: The ponderation between the Size and the Error.

   popuS: The initial population for the ErrorSize.

_V_a_l_u_e:

     Returns a list, with the knowledge bases, the inferred  classes,
     and the test errors. The structure of the list is:

     list(eS=errorS, kS=kBsS, cS=classesS, eM=errorM, kM=kBsM,
     cM=classesM)

     Where eS and eM, are referred to the error at "ErrorSize" and
     "MOGA" respectively. kS and kM, store the knowledge bases, and cS
     and cM, store the class vectors.

_E_x_a_m_p_l_e_s:

      data(trainM)
      out<-EXPERIMENTmO(trainM)

      # Show the distribution of errors of each 
      # iteration in ErrorSize
      errorS=data.frame(t(out$eS))
      boxplot(errorS)

      # Show the distribution of errors of each 
      # iteration in MOGA
      errorM=data.frame(t(out$eM))
      boxplot(errorM)

