def testLoadData(self): testPoints = [[0.307143,0.130137,0.050000], [0.365584,0.105479,0.050000], [0.178571,0.201027,0.050000], [0.272078,0.145548,0.050000], [0.318831,0.065411,0.050000], [0.190260,0.086986,0.050000], [0.190260,0.062329,0.072500], [0.120130,0.068493,0.072500], [0.225325,0.056164,0.072500], [0.213636,0.050000,0.072500] ] testValues = [-1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, -1.000000, -1.000000, -1.000000, -1.000000] filename = pathlocal + '/datasets/liver-disorders_normalized.arff.gz' adapter = ARFFAdapter(filename) container = adapter.loadData() points = container.getPoints() values = container.getValues() size = len(testPoints) dim = len(testPoints[0]) testVector = DataVector(dim) for rowIdx in xrange(size): points.getRow(rowIdx, testVector) for colIdx in xrange(dim): if cvar.USING_DOUBLE_PRECISION: self.assertEqual(testVector[colIdx], testPoints[rowIdx][colIdx]) else: self.assertAlmostEqual(testVector[colIdx], testPoints[rowIdx][colIdx]) self.assertEqual(values[rowIdx], testValues[rowIdx])
def testLoadData(self): testPoints = [[0.307143, 0.130137, 0.050000], [0.365584, 0.105479, 0.050000], [0.178571, 0.201027, 0.050000], [0.272078, 0.145548, 0.050000], [0.318831, 0.065411, 0.050000], [0.190260, 0.086986, 0.050000], [0.190260, 0.062329, 0.072500], [0.120130, 0.068493, 0.072500], [0.225325, 0.056164, 0.072500], [0.213636, 0.050000, 0.072500]] testValues = [ -1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, -1.000000, -1.000000, -1.000000, -1.000000 ] filename = pathlocal + '/datasets/liver-disorders_normalized.arff.gz' adapter = ARFFAdapter(filename) container = adapter.loadData() points = container.getPoints() values = container.getValues() size = len(testPoints) dim = len(testPoints[0]) testVector = DataVector(dim) for rowIdx in xrange(size): points.getRow(rowIdx, testVector) for colIdx in xrange(dim): if cvar.USING_DOUBLE_PRECISION: self.assertEqual(testVector[colIdx], testPoints[rowIdx][colIdx]) else: self.assertAlmostEqual(testVector[colIdx], testPoints[rowIdx][colIdx]) self.assertEqual(values[rowIdx], testValues[rowIdx])
def fromJson(cls, jsonObject): # initiate with train data, because they are always there specification = jsonObject['train'] resultContainer = ARFFAdapter.ARFFAdapter(specification['filename']).loadData('train') # load data for other categories for category, specification in list(jsonObject.items()): if not (category == 'module' or category == 'train'): from pysgpp.extensions.datadriven.data.ARFFAdapter import ARFFAdapter container = ARFFAdapter.ARFFAdapter(specification['filename']).loadData(category) resultContainer = resultContainer.combine(container) return resultContainer
def testSave(self): filename = pathlocal + '/datasets/saving.arff.gz' testPoints = [[0.307143, 0.130137, 0.050000], [0.365584, 0.105479, 0.050000], [0.178571, 0.201027, 0.050000], [0.272078, 0.145548, 0.050000], [0.318831, 0.065411, 0.050000], [0.190260, 0.086986, 0.050000], [0.190260, 0.062329, 0.072500], [0.120130, 0.068493, 0.072500], [0.225325, 0.056164, 0.072500], [0.213636, 0.050000, 0.072500]] testValues = [ -1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, -1.000000, -1.000000, -1.000000, -1.000000 ] attributes = { "x0": "NUMERIC", "x1": "NUMERIC", "x2": "NUMERIC", "class": "NUMERIC", } size = len(testPoints) dim = len(testPoints[0]) point = DataVector(dim) points = DataMatrix(size, dim) for row in xrange(size): for col in xrange(dim): point[col] = testPoints[row][col] points.setRow(row, point) adapter = ARFFAdapter(filename) adapter.save(points, testValues, attributes) (points, values) = adapter.loadData().getPointsValues() size = len(testPoints) dim = len(testPoints[0]) testVector = DataVector(dim) for rowIdx in xrange(size): points.getRow(rowIdx, testVector) for colIdx in xrange(dim): if cvar.USING_DOUBLE_PRECISION: self.assertEqual(testVector[colIdx], testPoints[rowIdx][colIdx]) else: self.assertAlmostEqual(testVector[colIdx], testPoints[rowIdx][colIdx]) self.assertEqual(values[rowIdx], testValues[rowIdx]) os.remove(filename)
def testLoadSpecification(self): attributes = { "x0":"NUMERIC", "x1":"NUMERIC", "x2":"NUMERIC", "class":"NUMERIC", } filename = pathlocal + '/datasets/liver-disorders_normalized.arff.gz' adapter = ARFFAdapter(filename) spec = adapter.loadSpecification() testAttributes = spec.getAttributes() self.assertEqual(len(testAttributes), len(attributes)) for key in testAttributes.keys(): self.assertEqual(testAttributes[key],attributes[key])
def withTestingDataFromARFFFile(self, filename): """ Signals to use data from ARFF file for testing dataset @param filename: Filename where to read the data from @return: LearnerBuilder object itself """ adapter = ARFFAdapter(filename) dataContainer = adapter.loadData(DataContainer.TEST_CATEGORY) if self._learner.dataContainer is not None: dataContainer = self._learner.dataContainer.combine(dataContainer) self._learner.setDataContainer(dataContainer) else: self._learner.setDataContainer(dataContainer) return self
def withTestingDataFromARFFFile(self, filename): """ Signals to use data from ARFF file for testing dataset @param filename: Filename where to read the data from @return: LearnerBuilder object itself """ adapter = ARFFAdapter(filename) dataContainer = adapter.loadData(DataContainer.TEST_CATEGORY) if self._learner.dataContainer is not None: dataContainer = self._learner.dataContainer.combine(dataContainer) self._learner.setDataContainer(dataContainer) else: self._learner.setDataContainer(dataContainer) return self
def testLoadSpecification(self): attributes = { "x0": "NUMERIC", "x1": "NUMERIC", "x2": "NUMERIC", "class": "NUMERIC", } filename = pathlocal + '/datasets/liver-disorders_normalized.arff.gz' adapter = ARFFAdapter(filename) spec = adapter.loadSpecification() testAttributes = spec.getAttributes() self.assertEqual(len(testAttributes), len(attributes)) for key in testAttributes.keys(): self.assertEqual(testAttributes[key], attributes[key])
def setUp(self): files = ['/datasets/foldf_fold0.arff', '/datasets/foldf_fold1.arff', '/datasets/foldf_fold2.arff'] datasets = [] fileCounter = 0 self.dataContainer = ARFFAdapter(pathlocal + files[fileCounter]).loadData("train" + str(fileCounter)) for fname in files[1:]: fileCounter += 1 self.dataContainer = self.dataContainer.combine(ARFFAdapter(pathlocal + fname).loadData("train" + str(fileCounter))) self.policy = FilesFoldingPolicy(self.dataContainer) self.points = list(range(9)) self.values = list(range(9)) self.values.reverse()
def setUp(self): level = 2 dim = 2 l = 0.00001 self.classifier = Classifier() dataContainer = ARFFAdapter( pathlocal + "/datasets/classifier.train.arff").loadData() self.classifier.setDataContainer(dataContainer) foldingPolicy = FoldingPolicy(dataContainer) self.classifier.setFoldingPolicy(foldingPolicy) grid = Grid.createLinearGrid(dim) storage = grid.createGridGenerator() storage.regular(level) self.classifier.setGrid(grid) self.classifier.setLearnedKnowledge(LearnedKnowledge()) spec = TrainingSpecification() spec.setL(l) spec.setCOperator(createOperationLaplace(grid)) self.classifier.setSpecification(spec) stopPolicy = TrainingStopPolicy() stopPolicy.setAdaptiveIterationLimit(0) self.classifier.setStopPolicy(stopPolicy) solver = CGSolver() #solver.attachEventController(InfoToScreen()) solver.setImax(500) solver.setReuse(True) self.classifier.setSolver(solver)
def withTrainingDataFromARFFFile(self, filename, name="train"): dataContainer = ARFFAdapter(filename).loadData(name) if self.__learner.dataContainer != None: self.__learner.setDataContainer(self.__learner.dataContainer.combine(dataContainer)) else: self.__learner.setDataContainer(dataContainer) return self
def withTestingDataFromARFFFile(self, filename): dataContainer = ARFFAdapter(filename).loadData(DataContainer.TEST_CATEGORY) if self.__learner.dataContainer != None: self.__learner.setDataContainer(self.__learner.dataContainer.combine(dataContainer)) else: self.__learner.setDataContainer(dataContainer) return self
def testSave(self): filename = pathlocal + '/datasets/saving.arff.gz' testPoints = [[0.307143,0.130137,0.050000], [0.365584,0.105479,0.050000], [0.178571,0.201027,0.050000], [0.272078,0.145548,0.050000], [0.318831,0.065411,0.050000], [0.190260,0.086986,0.050000], [0.190260,0.062329,0.072500], [0.120130,0.068493,0.072500], [0.225325,0.056164,0.072500], [0.213636,0.050000,0.072500] ] testValues = [-1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, -1.000000, -1.000000, -1.000000, -1.000000] attributes = { "x0":"NUMERIC", "x1":"NUMERIC", "x2":"NUMERIC", "class":"NUMERIC", } size = len(testPoints) dim = len(testPoints[0]) point = DataVector(dim) points = DataMatrix(size, dim) for row in xrange(size): for col in xrange(dim): point[col] = testPoints[row][col] points.setRow(row, point) adapter = ARFFAdapter(filename) adapter.save(points, testValues, attributes) (points, values) = adapter.loadData().getPointsValues() size = len(testPoints) dim = len(testPoints[0]) testVector = DataVector(dim) for rowIdx in xrange(size): points.getRow(rowIdx, testVector) for colIdx in xrange(dim): if cvar.USING_DOUBLE_PRECISION: self.assertEqual(testVector[colIdx], testPoints[rowIdx][colIdx]) else: self.assertAlmostEqual(testVector[colIdx], testPoints[rowIdx][colIdx]) self.assertEqual(values[rowIdx], testValues[rowIdx]) os.remove(filename)
def withTrainingDataFromARFFFile(self, filename, name="train"): """ Signals to use data from ARFF file for training dataset @param filename: Filename where to read the data from @param name: Category name, default: "train" """ dataContainer = ARFFAdapter(filename).loadData(name) if self._learner.dataContainer is not None: dataContainer = self._learner.dataContainer.combine(dataContainer) self._learner.setDataContainer(dataContainer) else: self._learner.setDataContainer(dataContainer) return self
def setUp(self): files = ['/datasets/foldf_fold0.arff', '/datasets/foldf_fold1.arff', '/datasets/foldf_fold2.arff'] datasets = [] fileCounter = 0 self.dataContainer = ARFFAdapter(pathlocal + files[fileCounter]).loadData("train" + str(fileCounter)) for fname in files[1:]: fileCounter += 1 self.dataContainer = self.dataContainer.combine(ARFFAdapter(pathlocal + fname).loadData("train" + str(fileCounter))) self.policy = FilesFoldingPolicy(self.dataContainer) self.points = range(9) self.values = range(9) self.values.reverse()
def toString(self): # save the data as a file, if it's not saved yet for category, specification in list(self.specifications.items()): if not self.specifications[category].isSaved(): from pysgpp.extensions.datadriven.data.ARFFAdapter import ARFFAdapter ARFFAdapter.ARFFAdapter(self.specifications[category].getFilename())\ .save(self.getPoints(category), self.getValues(category), specification.getAttributes()) specification.setSaved() serializedString = "'module' : '" + self.__module__ + "',\n" for category in list(self.specifications.keys()): serializedString += "'" + category + "' : " + self.specifications[category].toString() + ",\n" return "{" + serializedString.rstrip(",\n") + "}\n"
class TestFilesFoldingPolicy(unittest.TestCase): ## Set up the variables def setUp(self): files = [ '/datasets/foldf_fold0.arff', '/datasets/foldf_fold1.arff', '/datasets/foldf_fold2.arff' ] datasets = [] fileCounter = 0 self.dataContainer = ARFFAdapter( pathlocal + files[fileCounter]).loadData("train" + str(fileCounter)) for fname in files[1:]: fileCounter += 1 self.dataContainer = self.dataContainer.combine( ARFFAdapter(pathlocal + fname).loadData("train" + str(fileCounter))) self.policy = FilesFoldingPolicy(self.dataContainer) self.points = range(9) self.values = range(9) self.values.reverse() ## # Tests the function @link python.learner.folding.FoldingPolicy.FoldingPolicy.next() FilesFoldingPolicy.next() @endlink def testNext(self): # validationCorrectData = [[4,0],[5,1], [6,2], [7,8,3]] # self.assertEqual(self.level, len(self.policy.dataFold)) step = 0 for l in self.policy: points = l.getPoints() testPoints = self.points[:step * 3] + self.points[step * 3 + 3:] values = l.getValues() testValues = self.values[:step * 3] + self.values[step * 3 + 3:] self.assertEqual(points.getNrows(), len(testPoints)) self.assertEqual(len(values), len(testValues)) for i in xrange(points.getSize()): self.assertEqual(points.get(i, 0), testPoints[i]) self.assertEqual(values[i], testValues[i]) step += 1
def testLearnDataWithFolding(self, ): correct = [ 0.6612903226, 0.1428571429, 0.5741935484, 0.9142857143, 0.6193548387, 0.5142857143, 0.5870967742, 0.7714285714, 0.6032258065, 0.5714285714, 0.6387096774, 0.4000000000, 0.5935483871, 0.7428571429, 0.6193548387, 0.5142857143, 0.5903225806, 0.7714285714, 0.6063492063, 0.5666666667 ] level = 2 dim = 6 l = 0.00001 self.classifier = Classifier() dataContainer = ARFFAdapter( pathlocal + "/../../../datasets/liver/liver-disorders_normalized.arff" ).loadData() self.classifier.setDataContainer(dataContainer) foldingPolicy = SequentialFoldingPolicy(dataContainer, 10) self.classifier.setFoldingPolicy(foldingPolicy) grid = Grid.createLinearGrid(dim) storage = grid.getGenerator() storage.regular(level) self.classifier.setGrid(grid) self.classifier.setLearnedKnowledge(LearnedKnowledge()) spec = TrainingSpecification() spec.setL(l) spec.setCOperator(createOperationLaplace(grid)) spec.setCOperatorType('laplace') self.classifier.setSpecification(spec) stopPolicy = TrainingStopPolicy() stopPolicy.setAdaptiveIterationLimit(0) self.classifier.setStopPolicy(stopPolicy) self.classifier.setSolver(CGSolver()) self.classifier.learnDataWithFolding() for i in range(10): self.assertAlmostEqual(correct[2 * i], self.classifier.trainAccuracy[i]) self.assertAlmostEqual(correct[2 * i + 1], self.classifier.testAccuracy[i])
class TestFilesFoldingPolicy(unittest.TestCase): ## Set up the variables def setUp(self): files = ['/datasets/foldf_fold0.arff', '/datasets/foldf_fold1.arff', '/datasets/foldf_fold2.arff'] datasets = [] fileCounter = 0 self.dataContainer = ARFFAdapter(pathlocal + files[fileCounter]).loadData("train" + str(fileCounter)) for fname in files[1:]: fileCounter += 1 self.dataContainer = self.dataContainer.combine(ARFFAdapter(pathlocal + fname).loadData("train" + str(fileCounter))) self.policy = FilesFoldingPolicy(self.dataContainer) self.points = range(9) self.values = range(9) self.values.reverse() ## # Tests the function @link python.learner.folding.FoldingPolicy.FoldingPolicy.next() FilesFoldingPolicy.next() @endlink def testNext(self): # validationCorrectData = [[4,0],[5,1], [6,2], [7,8,3]] # self.assertEqual(self.level, len(self.policy.dataFold)) step = 0 for l in self.policy: points = l.getPoints() testPoints = self.points[:step*3] + self.points[step*3+3:] values = l.getValues() testValues = self.values[:step*3] + self.values[step*3+3:] self.assertEqual(points.getNrows(), len(testPoints)) self.assertEqual(len(values), len(testValues)) for i in xrange(points.getSize()): self.assertEqual(points.get(i,0), testPoints[i]) self.assertEqual(values[i], testValues[i]) step += 1
def constructObjectsFromOptions(cls, options): #Create builder for specified learner builder = LearnerBuilder() if options.regression: builder.buildRegressor() else: builder.buildClassifier() # load alpha file if options.alpha: builder.withInitialAlphaFromARFFFile(options.alpha) #dataset options if len(options.data) == 1: builder.withTrainingDataFromARFFFile(options.data[0]) elif len(options.data) > 1: fileCounter = 0 for filename in options.data: builder.withTrainingDataFromARFFFile( filename, DataContainer.TRAIN_CATEGORY + str(fileCounter)) fileCounter += 1 else: raise Exception('Define the path to the training data set') if options.test: builder.withTestingDataFromARFFFile(options.test) #grid options builder = builder.withGrid() if options.grid: builder.fromFile(options.grid) else: try: if options.level: builder.withLevel(options.level) if options.polynom: builder.withPolynomialBase(options.polynom) if options.trapezoidboundary: builder.withBorder(BorderTypes.TRAPEZOIDBOUNDARY) elif options.completeboundary: builder.withBorder(BorderTypes.COMPLETEBOUNDARY) # @fixme (khakhutv)the name "NONE" for the border type should be changed to something more meaningful elif options.border: builder.withBorder(BorderTypes.NONE) except: raise Exception('Grid configuration arguments incorrect') if options.adapt_start: builder.withStartingIterationNumber(options.adapt_start) #training specification builder = builder.withSpecification() if options.adapt_rate: builder.withAdaptRate(options.adapt_rate) elif options.adapt_points: builder.withAdaptPoints(options.adapt_points) if options.regparam: builder.withLambda(options.regparam) if options.zeh: if options.zeh == 'laplace': builder.withLaplaceOperator() elif options.zeh == 'identity': builder.withIdentityOperator() else: raise Exception('Incorrect regulariation operator type') if options.adapt_threshold: builder.withAdaptThreshold(options.adapt_threshold) #stop policy builder = builder.withStopPolicy() if options.adaptive: builder.withAdaptiveItarationLimit(options.adaptive) if options.grid_limit: builder.withGridSizeLimit(options.grid_limit) if options.mse_limit: builder.withMSELimit(options.mse_limi) if options.epochs_limit: builder.withEpochsLimit(options.epochs_limit) # linear solver builder = builder.withCGSolver() if options.r: builder.withAccuracy(options.r) if options.max_r: builder.withThreshold(options.max_r) if options.imax: builder.withImax(options.imax) #presentor if options.verbose: # print to the screen if options.regression: builder.withProgressPresenter(InfoToScreenRegressor()) else: builder.withProgressPresenter(InfoToScreen()) if options.stats: builder.withProgressPresenter(InfoToFile(options.stats)) #checkpoint if options.checkpoint: title = os.path.basename(options.checkpoint) path = os.path.dirname(options.checkpoint) checkpointController = CheckpointController(title, path) builder.withCheckpointController(checkpointController) # Folding if options.mode in [ 'fold', 'folds', 'foldstratified', 'foldf', 'foldr' ]: if options.mode == 'fold': builder.withRandomFoldingPolicy() elif options.mode == 'folds': builder.withSequentialFoldingPolicy() elif options.mode in ['foldstratified', 'foldr']: builder.withStratifiedFoldingPolicy() elif options.mode == 'foldf': builder.withFilesFoldingPolicy() if options.seed: builder.withSeed(options.seed) if options.level: builder.withLevel(options.level) #Get Results and perform wanted action learner = builder.andGetResult() options.mode = options.mode.lower() if options.mode == 'normal': learner.learnData() elif options.mode == 'test': learner.learnDataWithTest() elif options.mode == 'apply': learner.applyData(ARFFAdapter(options.data).loadData().getPoints()) elif options.mode in [ 'fold', 'folds', 'foldstratified', 'foldf', 'foldr' ]: builder.getCheckpointController().generateFoldValidationJob( 'PUT_YOUR_EMAIL_HERE') elif options.mode in ['eval', 'evalstdin']: raise Exception('This action is not implemented yet') else: raise Exception('Incorrect action configuration')
def constructObjectsFromFile(cls, filename): configuration = configparser.ConfigParser() configuration.readfp(open(filename, 'r')) #Create builder for specified learner builder = LearnerBuilder() learner_type = configuration.get('learner', 'type') if learner_type == 'classification': builder.buildClassifier() elif learner_type == 'regression': builder.buildRegressor() else: raise Exception('Wrong learner type in job configuration file') #dataset options options = TerminalController.itemsToDict(configuration.items('data')) if options['file_type'] == 'arff': if 'train_file' in options: if type(options['train_file']) != list: builder.withTrainingDataFromARFFFile(options['train_file']) else: fileCounter = 0 for train_file in options['train_file']: builder.withTrainingDataFromARFFFile( train_file, DataContainer.TRAIN_CATEGORY + str(fileCounter)) fileCounter += 1 else: raise Exception( 'Path to file with training data set is not defined in configurationfile' ) if 'test_file' in options: builder.withTestingDataFromARFFFile(options['test_file']) else: raise Exception('Unsupported data type in job configuration file') #grid options builder = builder.withGrid() options = TerminalController.itemsToDict(configuration.items('grid')) if 'grid_file' in options: builder.fromFile(options['grid_file']) else: try: if 'level' in options: builder.withLevel(int(options['level'])) if 'polynomial' in options: builder.withPolynomialBase(int(options['polynomial'])) if 'border' in options: builder.withBorder(options['border']) except: raise Exception('Grid configuration in job file is incorrect') #training specification builder = builder.withSpecification() options = TerminalController.itemsToDict( configuration.items('refinement')) if 'points' in options: if '.' in options['points']: builder.withAdaptRate(float(options['points'])) else: builder.withAdaptPoints(int(options['points'])) options = TerminalController.itemsToDict( configuration.items('learner')) if 'regularization_parameter' in options: builder.withLambda(float(options['regularization_parameter'])) if 'regularization_operator' in options: if options['regularization_operator'] == 'laplace': builder.withLaplaceOperator() elif options['regularization_operator'] == 'idenitty': builder.withIdentityOperator() else: raise Exception('Incorrect regulariation operator type') if 'threshold' in options: builder.withAdaptThreshold(float(options['threshold'])) #stop policy builder = builder.withStopPolicy() options = TerminalController.itemsToDict( configuration.items('refinement')) if 'iterations' in options: builder.withAdaptiveItarationLimit(int(options['iterations'])) if 'gridsize' in options: builder.withGridSizeLimit(int(options['gridsize'])) if 'mse' in options: builder.withMSELimit(float(options['mse'])) if 'epochs' in options: builder.withEpochsLimit(int(options['epochs'])) # linear solver builder = builder.withCGSolver() options = TerminalController.itemsToDict(configuration.items('solver')) if 'accuracy' in options: builder.withAccuracy(float(options['accuracy'])) if 'imax' in options: builder.withImax(int(options['imax'])) if 'max_threshold' in options: builder.withThreshold(float(options['max_threshold'])) #presentor options = TerminalController.itemsToDict(configuration.items('output')) if 'type' in options: types = options['type'].split(',') for type in types: if type.strip() == 'InfoToScreen': builder.withProgressPresenter(InfoToScreen()) if type.strip() == 'InfoToScreenRegressor': builder.withProgressPresenter(InfoToScreenRegressor()) elif type.strip() == 'InfoToFile': if 'filename' in options: builder.withProgressPresenter( InfoToFile(options['filename'])) else: raise Exception( 'Define filename in order to use InfoToFile output' ) #checkpoint options = TerminalController.itemsToDict( configuration.items('checkpoints')) if 'name' in options: path = options['path'] if 'path' in options else None interval = options[ 'interval'] if 'inte rval' in options else None checkpointController = CheckpointController( options['name'], path, interval) if 'restore_iteration' in options: learner = checkpointController.loadAll( options['restore_iteration']) builder.withCheckpointController(checkpointController) #Get Results and perform wanted action # if learner was not created by checkpoint controller, create it with learner builder try: if learner not in dir(): learner = builder.andGetResult() except: learner = builder.andGetResult() # Folding options = TerminalController.itemsToDict( configuration.items('folding')) if options.type in [ 'fold', 'folds', 'foldstratified', 'foldr', 'foldf' ]: if options.type == 'fold': builder.withRandomFoldingPolicy() elif options.type == 'folds': builder.withSequentialFoldingPolicy() elif options.type in ['foldstratified', 'foldr']: builder.withStratifiedFoldingPolicy() elif options.type == 'foldf': builder.withFilesFoldingPolicy() if options.seed: builder.withSeed(options.seed) if options.level: builder.withLevel(options.level) else: raise Exception('Unknown folding type') options = TerminalController.itemsToDict( configuration.items('learner')) if options['action'] == 'learn': if ('with_testing' not in options) or options['with_testing'].lower() == 'no': learner.learnData() elif options['with_testing'].lower() == 'yes': learner.learnDataWithTest() else: raise Exception( 'with_testion can only be set to "yes" or "no"') elif options['action'] == 'apply': points_file = configuration.get('data', 'points_file') if points_file != None: learner.applyData( ARFFAdapter(points_file).loadData().getPoints()) else: raise Exception( 'To evaluate value of points define file path "points_file" in the section "data"' ) elif options['action'] == 'fold': builder.getCheckpointController().generateFoldValidationJob( 'PUT_YOUR_EMAIL_HERE') else: raise Exception('Incorrect action in job configuration file')