def train(self, table_name, model_table, isRegression=False, parallel=False, verbose=False, eta=0.1, reg=0.001, kernel_func=None, nu=0.005, slambda=0.05):
            cursor = self.dbconn.getCursor()
            if(isRegression==True and kernel_func==None):
                raise Exception ('Parameter kernel_func required for SVM Regression')
            
            #Save Model Params, we will need this during prediction    
            self.model = {}
            self.model['isRegression'] = isRegression
            self.model['model_table'] = model_table
            self.model['parallel'] = parallel
            self.model['verbose'] = verbose
            self.model['eta'] = eta 
            self.model['reg'] = reg
            self.model['kernel_func'] = kernel_func
            self.model['nu'] = nu
            self.model['slambda'] = slambda                    
            
            stmt = ''' '''
            if(isRegression==True):
                stmt =  '''select {madlib_schema}.svm_regression('{table_name}',
                                                        '{model_table}',
                                                        {parallel},
                                                        '{kernel_func}',
                                                        {verbose},
                                                        {eta},
                                                        {nu},
                                                        {slambda}
                                                        );
                        '''.format(
                                   table_name=table_name,
                                   model_table=model_table,
                                   verbose=verbose,
                                   parallel=parallel,
                                   eta=eta,                                 
                                   kernel_func=kernel_func,
                                   nu=nu,
                                   slambda=slambda,
                                   madlib_schema=self.dbconn.madlib_schema
                                  )
                
            #Linear SVM Classification
            elif(kernel_func==None):
                stmt =  '''select {madlib_schema}.lsvm_classification('{table_name}',
                                                             '{model_table}',
                                                             {parallel},
                                                             {verbose},
                                                             {eta},
                                                             {reg}
                                                            );
                        '''.format(
                                   table_name=table_name,
                                   model_table=model_table,
                                   verbose=verbose,
                                   parallel=parallel,
                                   eta=eta,
                                   reg=reg,
                                   madlib_schema=self.dbconn.madlib_schema
                                  )
                
            #SVM Classification
            else:
                stmt =  '''select {madlib_schema}.svm_classification ('{table_name}',
                                                             '{model_table}',
                                                             {parallel},
                                                             '{kernel_func}',
                                                             {verbose},
                                                             {eta},
                                                             {nu}
                                                            );
                        '''.format(
                                   table_name=table_name,
                                   model_table=model_table,
                                   verbose=verbose,
                                   parallel=parallel,
                                   eta=eta,                                 
                                   kernel_func=kernel_func,
                                   nu=nu,
                                   madlib_schema=self.dbconn.madlib_schema
                                  )                                             
               
            
            logging.info('statement :{0}'.format(stmt))
            
            cursor.execute(stmt)
            
            row_set = self.dbconn.fetchRowsFromCursor(cursor)
            mdl_params = self.dbconn.fetchModelParams(row_set)
            
            for param in mdl_params:
                self.model[param] = mdl_params[param]
                
            return self.model
Get the split item children defined on the splitter.
dataset/ETHPy150Open pivotalsoftware/pymadlib/pymadlib/pymadlib.py/SVM.train--crossover with--dataset/ETHPy150Open nucleic/enaml/enaml/widgets/splitter.py/Splitter.split_items