def __call__(self, data, weight=None): """Creates a Bayes model from the data in origTrainingData. """ if not AZBaseClasses.AZLearner.__call__(self, data, weight): return None if data.domain.classVar.varType != orange.VarTypes.Discrete: raise Exception( "AZorngCvBayes can only be used for classification.") #Remove from the domain any unused values of discrete attributes including class data = dataUtilities.getDataWithoutUnusedValues(data, True) #dataUtilities.rmAllMeta(data) if len(data.domain.getmetas()) == 0: trainingData = data else: trainingData = dataUtilities.getCopyWithoutMeta(data) # Create the imputer self.imputer = orange.ImputerConstructor_average(trainingData) # Impute the data trainingData = self.imputer(trainingData) if self.scale: self.scalizer = dataUtilities.scalizer() self.scalizer.scaleClass = False self.scalizer.nMin = -1 self.scalizer.nMax = 1 self.trainData = self.scalizer.scaleAndContinuizeData(trainingData) else: self.trainData = trainingData self.scalizer = None impData = self.imputer.defaults #Convert the ExampleTable to CvMat CvMatrices = dataUtilities.ExampleTable2CvMat(self.trainData) mat = CvMatrices["matrix"] responses = CvMatrices["responses"] varTypes = CvMatrices["varTypes"] missingDataMask = CvMatrices["missing_data_mask"] #Create the model it MUST be created with the NON DEFAULT constructor or must call create classifier = ml.CvNormalBayesClassifier() classifier.clear() #Train the model #CvNormalBayesClassifier::train(const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx =0, const CvMat* _sample_idx=0, bool update=false) classifier.train(mat, responses, None, None, False) return CvBayesClassifier(classifier=classifier, classVar=trainingData.domain.classVar, imputeData=impData, verbose=self.verbose, varNames=CvMatrices["varNames"], nIter=None, basicStat=self.basicStat, NTrainEx=len(trainingData), scalizer=self.scalizer, parameters=self.parameters)
def getMahalanobisResults(predictor, invCovMatFile=None, centerFile=None, dataTableFile=None): domain = None if predictor.highConf == None and predictor.lowConf == None: return None, None if not dataTableFile and (not hasattr(predictor, "trainDataPath") or not predictor.trainDataPath): print "The predictor does not have a trainDataPath specifyed. We need it for calculating Mahalanobis results!" return None, None testData = dataUtilities.attributeDeselectionData(predictor.exToPred, ["SMILEStoPred"]) if not dataTableFile: trainData = dataUtilities.DataTable(predictor.trainDataPath) domain = trainData.domain else: trainData = None domain = predictor.model.domain ExampleFix = dataUtilities.ExFix(domain, None, False) exFixed1 = ExampleFix.fixExample(testData[0]) if testData.hasMissingValues(): if not trainData: averageImputer = orange.Imputer_defaults( predictor.model.imputeData) else: averageImputer = orange.ImputerConstructor_average(trainData) dat = averageImputer(exFixed1) else: dat = exFixed1 tab = dataUtilities.DataTable(domain) tab.append(dat) MD = calcMahalanobis(trainData, tab, invCovMatFile, centerFile, dataTableFile, domain) near3neighbors = [(MD[0]["_train_id_near1"], MD[0]["_train_SMI_near1"]), (MD[0]["_train_id_near2"], MD[0]["_train_SMI_near2"]), (MD[0]["_train_id_near3"], MD[0]["_train_SMI_near3"])] avg3nearest = MD[0]["_train_av3nearest"] if avg3nearest < predictor.highConf: confStr = predictor.highConfString elif avg3nearest > predictor.lowConf: confStr = predictor.lowConfString else: confStr = predictor.medConfString return near3neighbors, confStr
def __call__(self, examples, weight=0): # next function changes data set to a extended with unknown values def createLogRegExampleTable(data, weightID): setsOfData = [] for at in data.domain.attributes: # za vsak atribut kreiraj nov newExampleTable newData # v dataOrig, dataFinal in newData dodaj nov atribut -- continuous variable if at.varType == orange.VarTypes.Continuous: atDisc = orange.FloatVariable(at.name + "Disc") newDomain = orange.Domain(data.domain.attributes + [atDisc, data.domain.classVar]) newDomain.addmetas(data.domain.getmetas()) newData = orange.ExampleTable(newDomain, data) altData = orange.ExampleTable(newDomain, data) for i, d in enumerate(newData): d[atDisc] = 0 d[weightID] = 1 * data[i][weightID] for i, d in enumerate(altData): d[atDisc] = 1 d[at] = 0 d[weightID] = 0.000001 * data[i][weightID] elif at.varType == orange.VarTypes.Discrete: # v dataOrig, dataFinal in newData atributu "at" dodaj ee eno vreednost, ki ima vrednost kar ime atributa + "X" atNew = orange.EnumVariable(at.name, values=at.values + [at.name + "X"]) newDomain = orange.Domain( filter(lambda x: x != at, data.domain.attributes) + [atNew, data.domain.classVar]) newDomain.addmetas(data.domain.getmetas()) newData = orange.ExampleTable(newDomain, data) altData = orange.ExampleTable(newDomain, data) for i, d in enumerate(newData): d[atNew] = data[i][at] d[weightID] = 1 * data[i][weightID] for i, d in enumerate(altData): d[atNew] = at.name + "X" d[weightID] = 0.000001 * data[i][weightID] newData.extend(altData) setsOfData.append(newData) return setsOfData learner = LogRegLearner(imputer=orange.ImputerConstructor_average(), removeSingular=self.removeSingular) # get Original Model orig_model = learner(examples, weight) if orig_model.fit_status: print "Warning: model did not converge" # get extended Model (you should not change data) if weight == 0: weight = orange.newmetaid() examples.addMetaAttribute(weight, 1.0) extended_set_of_examples = createLogRegExampleTable(examples, weight) extended_models = [learner(extended_examples, weight) \ for extended_examples in extended_set_of_examples] ## print examples[0] ## printOUT(orig_model) ## print orig_model.domain ## print orig_model.beta ## print orig_model.beta[orig_model.continuizedDomain.attributes[-1]] ## for i,m in enumerate(extended_models): ## print examples.domain.attributes[i] ## printOUT(m) # izracunas odstopanja # get sum of all betas beta = 0 betas_ap = [] for m in extended_models: beta_add = m.beta[m.continuizedDomain.attributes[-1]] betas_ap.append(beta_add) beta = beta + beta_add # substract it from intercept #print "beta", beta logistic_prior = orig_model.beta[0] + beta # compare it to bayes prior bayes = orange.BayesLearner(examples) bayes_prior = math.log(bayes.distribution[1] / bayes.distribution[0]) # normalize errors ## print "bayes", bayes_prior ## print "lr", orig_model.beta[0] ## print "lr2", logistic_prior ## print "dist", orange.Distribution(examples.domain.classVar,examples) ## print "prej", betas_ap # error normalization - to avoid errors due to assumption of independence of unknown values dif = bayes_prior - logistic_prior positives = sum(filter(lambda x: x >= 0, betas_ap)) negatives = -sum(filter(lambda x: x < 0, betas_ap)) if not negatives == 0: kPN = positives / negatives diffNegatives = dif / (1 + kPN) diffPositives = kPN * diffNegatives kNegatives = (negatives - diffNegatives) / negatives kPositives = positives / (positives - diffPositives) ## print kNegatives ## print kPositives for i, b in enumerate(betas_ap): if b < 0: betas_ap[i] *= kNegatives else: betas_ap[i] *= kPositives #print "potem", betas_ap # vrni originalni model in pripadajoce apriorne niclele return (orig_model, betas_ap)
print "Example w/ missing values" print data[19] print "Imputed:" print imputer(data[19]) print impdata = imputer(data) for i in range(20, 25): print data[i] print impdata[i] print print "\n*** IMPUTING AVERAGE/MAJORITY VALUES ***\n" imputer = orange.ImputerConstructor_average(data) print "Example w/ missing values" print data[19] print "Imputed:" print imputer(data[19]) print impdata = imputer(data) for i in range(20, 25): print data[i] print impdata[i] print print "\n*** MANUALLY CONSTRUCTED IMPUTER ***\n"
def test_Impute(self): """Test missing values imputation Assure that imputation works for the svm models. Test on data with missing values """ ex1 = self.contTest[1] ex2 = self.contTest[6] self.assert_(ex1["DiscAttr2"] != "?", "The var DiscAttr2 shouldn't be missing!") self.assert_(ex2["Level"] != "?", "The var Level shouldn't be missing!") imputer = orange.ImputerConstructor_average(self.contTrain) svmL = AZorngCvSVM.CvSVMLearner( p=0.2 ) #Here if p=2 and scaleClass is False, is ok, but with p=2 and also scale calss, the model will have no support vectors. So, with p=0.2 and also scale class, it goes right. svmL.svm_type = 103 svm = svmL(self.contTrain) # Prediction for data as it is P1 = svm(ex1) P2 = svm(ex2) # Predictions changing one continuous and one discrete variable to 0 ex1["DiscAttr2"] = 0 ex2["Level"] = 0 P1_0 = svm(ex1) P2_0 = svm(ex2) # Predictions changing the same continuous and discrete variable to it's correspondent imputation value ex1["DiscAttr2"] = imputer.defaults["DiscAttr2"] ex2["Level"] = imputer.defaults["Level"] P1_imp = svm(ex1) P2_imp = svm(ex2) # Predictions changing the same continuous and discrete variable to '?' wich means that the same imputation # as in the last case will have to be made inside the classifier. So, the predicted value must be the same ex1["DiscAttr2"] = "?" ex2["Level"] = "?" self.assert_(ex1["DiscAttr2"] == "?", "The var DiscAttr2 should be missing now!") self.assert_(ex2["Level"] == "?", "The var Level should be missing now!") P1Miss = svm(ex1) P2Miss = svm(ex2) # Test if the prediction made for the example with mising value is the same as the one # for the example which missing values were substituted using the same method as the classifier does. self.assert_( round(P1_imp, 4) == round(P1Miss, 4), "Imputation was not made correctly inside the classifier") self.assert_( round(P2_imp, 4) == round(P2Miss, 4), "Imputation was not made correctly inside the classifier") # Assure that if other substitutions on those variables were made, the predicted value would be different, # and so, this is a valid method for testing the imputation self.assert_(round(P1.value, 4) != round( P2.value, 4)) # Just to assure that we are not comaring equal examples self.assert_(round(P1.value, 4) != round(P1_imp.value, 4)) self.assert_(round(P1_0.value, 4) != round(P1_imp.value, 4)) self.assert_(round(P2.value, 4) != round(P2_imp.value, 4)) self.assert_(round(P2_0.value, 4) != round(P2_imp.value, 4)) #Test the imputer for saved models # Save the model scratchdir = os.path.join(AZOC.SCRATCHDIR, "scratchdirSVMtest" + str(time.time())) os.mkdir(scratchdir) modelPath = os.path.join(scratchdir, "CvSVMModel") svm.write(modelPath) # Read in the model svmM = AZorngCvSVM.CvSVMread(modelPath) # Predict the ex1 and ex2 which are still the examples with missing values '?' self.assert_(ex1["DiscAttr2"] == "?", "Value of Var DiscAttr2 should be missing!") self.assert_(ex2["Level"] == "?", "Value of Var Level should be missing!") self.assert_( round(svmM(ex1), 4) == round(P1Miss, 4), "Imputation on loaded model is not correct") self.assert_( round(svmM(ex2), 4) == round(P2Miss, 4), "Imputation on loaded model is not correct") # Remove the scratch directory os.system("/bin/rm -rf " + scratchdir)
def __call__(self, data, weight = None): """Creates an SVM model from the data in origTrainingData. """ if not AZBaseClasses.AZLearner.__call__(self, data, weight): if self.verbose > 0: print "Could not create base class instance" return None dataUtilities.verbose = self.verbose #Remove from the domain any unused values of discrete attributes including class data = dataUtilities.getDataWithoutUnusedValues(data,True) #dataUtilities.rmAllMeta(data) if len(data.domain.getmetas()) == 0: trainingData = data else: trainingData = dataUtilities.getCopyWithoutMeta(data) # Create the imputer self.imputer = orange.ImputerConstructor_average(trainingData) # Impute the data trainingData = self.imputer(trainingData) if self.scaleData: self.scalizer = dataUtilities.scalizer() for attr in ("nMin","nMax","nClassMin","nClassMax"): setattr(self.scalizer, attr, getattr(self, attr)) #Only scale the class in regression. On classification, set scaleClass to False self.scalizer.scaleClass = self.scaleClass and trainingData.domain.classVar.varType == orange.VarTypes.Continuous or False self.scalizer.nClassMin = self.nClassMin self.scalizer.nClassMax = self.nClassMax self.trainData = self.scalizer.scaleAndContinuizeData(trainingData) else: self.trainData = trainingData self.scalizer = None impData=self.imputer.defaults #Adjust the svm type according to the problem (regression or classification) if self.svm_type != 102: if trainingData.domain.classVar.varType == orange.VarTypes.Continuous: if self.svm_type in (100,101): self.svm_type += 3 self.eps = self.epsR #Regression eps else: if self.svm_type in (103,104): self.svm_type -= 3 self.eps = self.epsC #Classification eps #Convert the ExampleTable to CvMat CvMatices = dataUtilities.ExampleTable2CvMat(self.trainData) mat = CvMatices["matrix"] responses = CvMatices["responses"] varTypes = CvMatices["varTypes"] #Configure SVM self.params self.params = ml.CvSVMParams() self.params.svm_type = self.svm_type self.params.kernel_type = self.kernel_type self.params.degree = self.degree self.params.gamma = self.gamma self.params.coef0 = self.coef0 self.params.C = self.C self.params.nu = self.nu self.params.p = self.p #Process the priors from a str, list or dict to a valid list priors = self.convertPriors(self.priors,trainingData.domain.classVar) if type(priors) == str: #If a string is returned, there was a failure, and it is the respective error mnessage. print priors return None if priors and self.params.svm_type != ml.CvSVM.C_SVC: priors = None if self.verbose > 0: print "WARNING: The priors will not have any effect. They can only be used with C_SVC SVM-Type." elif priors: priors = dataUtilities. List2CvMat(priors) self.params.class_weights = priors term_crit = cv.CvTermCriteria() term_crit.type = self.stopCrit #cv.CV_TERMCRIT_EPS # or CV_TERMCRIT_ITER term_crit.epsilon = self.eps #Or use: term_crit.max_iter = x term_crit.max_iter = self.maxIter #Or use: term_crit.max_iter = x self.params.term_crit = term_crit #Create the model classifier = ml.CvSVM() #Train the model #train(trainData, responses, varIdx, SampleIdx, Params) classifier.train(mat,responses,None,None,self.params) if classifier.get_support_vector_count() < 1: print "WARNING: The number of support vectors is 0." print "This could be becasue the margin between the hyper plane and the support vectors has become zero." print "Try to modify the parameters controlling the margin. " print "For example decrease C or p(regression only)." print "No SVM model returned!" return None else: return CvSVMClassifier(classifier = classifier, classVar = data.domain.classVar, scalizer = self.scalizer, imputeData=impData, verbose = self.verbose, varNames = CvMatices["varNames"], basicStat = self.basicStat, NTrainEx = len(trainingData), parameters = self.parameters)
def test_BuiltIn_Impute(self): """Test RF BuiltIn missing values imputation Assure that imputation works for the rf models. Test on data with missing values """ #This data is loaded here to speed up the test suite since it is too big contTestDataPath = os.path.join(AZOC.AZORANGEHOME, "tests/source/data/linearTest.tab") contTrainDataPath = os.path.join(AZOC.AZORANGEHOME, "tests/source/data/linearTrain.tab") contTrain = dataUtilities.DataTable(contTrainDataPath) contTest = dataUtilities.DataTable(contTestDataPath) ex1 = contTest[5] ex2 = contTest[2] AttrEx1 = "Desc 71" AttrEx2 = "Desc 72" self.assert_(ex1[AttrEx1] != "?", "The var Desc 671 shouldn't be missing!") self.assert_(ex2[AttrEx2] != "?", "The var Desc 138 shouldn't be missing!") imputer = orange.ImputerConstructor_average(contTrain) RFlearner = AZorngRF.RFLearner(NumThreads = 1, maxDepth = "20", minSample = "5", useSurrogates = "false", getVarVariance = "false", \ nActVars = "0", nTrees = "100", forestAcc = "0.001", termCrit = "0",useBuiltInMissValHandling = True ) rf = RFlearner(contTrain) # Prediction for data as it is P1 = rf(ex1) P2 = rf(ex2) # Predictions changing one continuous and one discrete variable to 0 ex1[AttrEx1] = 0 ex2[AttrEx2] = 0 P1_0 = rf(ex1) P2_0 = rf(ex2) # Predictions changing the same continuous and discrete variable to it's correspondent imputation value #ex1["Desc 71"]=imputer.defaults["Desc 71"] #ex2["Desc 138"]=imputer.defaults["Desc 138"] #P1_imp=rf(ex1) #P2_imp=rf(ex2) # Predictions changing the same continuous and discrete variable to '?' wich means that the same imputation # as in the last case will have to be made inside the classifier. So, the predicted value must be the same ex1[AttrEx1] = "?" ex2[AttrEx2] = "?" self.assert_(ex1[AttrEx1] == "?", "The var Desc 71 should be missing now!") self.assert_(ex2[AttrEx2] == "?", "The var Desc 138 should be missing now!") P1Miss = rf(ex1) P2Miss = rf(ex2) # Test if the prediction made for the example with mising value is the same as the one # for the example which missing values were substituted using the same method as the classifier does. #self.assert_(P1_imp==P1Miss,"Imputation was not made correctly inside the classifier") #self.assert_(P2_imp==P2Miss,"Imputation was not made correctly inside the classifier") # Assure that if other substitutions on those variables were made, the predicted value would be different, # and so, this is a valid method for testing the imputation self.assert_( P1.value != P2.value) # Just to assure that we are not comaring equal examples self.assert_( P1.value != P1Miss.value, "The imputed 1 was the same as the original ... try other example") self.assert_( P1_0.value != P1Miss.value, "The imputed 1 was the same as the replaced by 0. The classifier may be replacing missing values by 0" ) self.assert_( P2.value != P2Miss.value, "The missing imputed 2 was the same as the original ... try other example" ) #self.assert_(P2_0.value!=P2Miss.value,"The missing imputed 2 was the same as the replaced by 0. The classifier may be replacing missing values by 0") self.assert_(rf.useBuiltInMissValHandling == True) #Test the imputer for saved models # Save the model scratchdir = os.path.join(AZOC.SCRATCHDIR, "scratchdirTest" + str(time.time())) os.mkdir(scratchdir) modelPath = os.path.join(scratchdir, "RFModel") rf.write(modelPath) # Read in the model rfM = AZorngRF.RFread(modelPath) self.assert_(rfM.useBuiltInMissValHandling == True) # Predict the ex1 and ex2 which are still the examples with missing values '?' self.assert_(ex1[AttrEx1] == "?", "Value of Var Desc 6 should be missing!") self.assert_(ex2[AttrEx2] == "?", "Value of Var Desc 71 should be missing!") self.assert_( rfM(ex1) == P1Miss, "Imputation on loaded model is not correct") self.assert_( rfM(ex2) == P2Miss, "Imputation on loaded model is not correct") # Remove the scratch directory os.system("/bin/rm -rf " + scratchdir)
def calcMahalanobis(data, testData, invCovMatFile=None, centerFile=None, dataTableFile=None, domain=None, nNN=NO_OF_NEIGHBORS): """ Calculates Mahalanobis distances. The data should only contain attributes that are relevant for similarity. OBS data is assumed to have a response variable. data - X matrix used to calculate the covariance matrix testData - the examples in an ExampleTable object for which to calculate the MDs Returns a list of Mahalanobis distances between the examples in testData and training data. The elements of the list are dictionaries, giving the Mahalanobis distances to the average (_MD), the nearest neighbor and an average of the 3 nearest neighbors (_train_av3nearest). """ # Impute any missing valuesi if data: averageImputer = orange.ImputerConstructor_average(data) data = averageImputer(data) #If Class is continuous and all class values are unknown (and they usually are in ex to predict), the imputer cannot be created. # Since we are only using attributes, not the class, we will assign 0 to the class values in order to impute the testData if testData.domain.classVar and testData.domain.classVar.varType == orange.VarTypes.Continuous: for ex in testData: if ex.getclass().isSpecial(): ex.setclass(0) # This can also happens when calculating a single example with missing attributes try: averageImputer = orange.ImputerConstructor_average(testData) except: for ex in testData: for attr in [ a for a in testData.domain.attributes if a.varType == orange.VarTypes.Continuous ]: if ex[attr].isSpecial(): ex[attr] = 0 averageImputer = orange.ImputerConstructor_average(testData) testData = averageImputer(testData) #Test if there is any non-numeric value within the dataset for ex in testData: #It is much faster to address the ex elements by their position instead of the correpondent name for idx in range(len(ex.domain.attributes)): if not miscUtilities.isNumber(ex[idx].value): raise Exception("Cannot calculate Mahalanobis distances. The attribute '" + \ ex.domain.attributes[idx].name + "' has non-numeric values. Ex: " + \ str(ex[idx].value)) if data: trainingSet = getTrainingSet(data) trainingset_descriptor_names = trainingSet.descr_names else: trainingSet = None trainingset_descriptor_names = [ attr.name for attr in domain.attributes ] mahalanobisCalculator = Mahalanobis.MahalanobisDistanceCalculator( trainingSet, invCovMatFile, centerFile, dataTableFile) MDlist = [] for ex in testData: # Create a numeric vector from the example and assure the same order as in trainingset_descriptor_names descriptor_values = [] for name in trainingset_descriptor_names: try: descriptor_values.append(float(ex[name].value)) except: raise Exception( "Not possible to calculate Mahalanobis distances. Some attribute is not numeric." ) #descriptor_values = [1.5] * len(trainingset_descriptor_names) MD = mahalanobisCalculator.calculateDistances(descriptor_values, nNN) MDlist.append(MD) return MDlist
def __call__(self, data, weight=None): """Creates a Boost model from the data in origTrainingData. """ if not AZBaseClasses.AZLearner.__call__(self, data, weight): return None if data.domain.classVar.varType != orange.VarTypes.Discrete: print "AZorngCvBoost can only be used for binary classification." return None #Remove from the domain any unused values of discrete attributes including class data = dataUtilities.getDataWithoutUnusedValues(data, True) #dataUtilities.rmAllMeta(data) if len(data.domain.getmetas()) == 0: trainingData = data else: trainingData = dataUtilities.getCopyWithoutMeta(data) # Create the imputer self.imputer = orange.ImputerConstructor_average(trainingData) # Impute the data self.trainData = self.imputer(trainingData) impData = self.imputer.defaults #Convert the ExampleTable to CvMat CvMatrices = dataUtilities.ExampleTable2CvMat(self.trainData) mat = CvMatrices["matrix"] responses = CvMatrices["responses"] varTypes = CvMatrices["varTypes"] missingDataMask = CvMatrices["missing_data_mask"] #Configure Boost params #First, Correct any wrong parameters Combination: # CVBOOSTTYPE = { "DISCRETE":0, "REAL":1, "LOGIT":2, "GENTLE":3 } # CVBOOSTSPLITCRIT = { "DEFAULT":0, "GINI":1, "MISCLASS":3, "SQERR":4 } if self.boost_type not in AZOC.CVBOOSTTYPE: print "ERROR: Bad value for parameter boost_type. Possible values: " + string.join( [x for x in AZOC.CVBOOSTTYPE], ", ") return None if self.split_criteria not in AZOC.CVBOOSTSPLITCRIT: print "ERROR: Bad value for parameter split_criteria. Possible values: " + string.join( [x for x in AZOC.AZOC.CVBOOSTSPLITCRIT], ", ") return None if self.boost_type == "DISCRETE": if self.split_criteria not in ["MISCLASS", "GINI"]: print "WARNING: For Discrete type, the split Criteria must be MISCLASS or GINI. MISCLASS was used by default." self.split_criteria = "MISCLASS" if self.boost_type == "REAL": if self.split_criteria not in ["MISCLASS", "GINI"]: print "WARNING: For REAL type, the split Criteria must be MISCLASS or GINI. GINI was used by default." self.split_criteria = "GINI" if self.boost_type in ["LOGIT", "GENTLE"]: if self.split_criteria != "SQERR": print "WARNING: For LOGIT and GENTLE types, the split Criteria must be SQERR. SQERR was used by default." self.split_criteria = "SQERR" params = ml.CvBoostParams() params.boost_type = AZOC.CVBOOSTTYPE[self.boost_type] params.split_criteria = AZOC.CVBOOSTSPLITCRIT[self.split_criteria] params.weak_count = self.weak_count params.weight_trim_rate = self.weight_trim_rate params.max_depth = self.max_depth params.use_surrogates = self.use_surrogates #Create the model it MUST be created with the NON DEFAULT constructor or must call create classifier = ml.CvBoost() #Train the model #train(const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, CvBoostParams params=CvBoostParams(), bool update=false) #sampleWeights = cv.cvCreateMat(1,len(self.trainData),cv.CV_32FC1) #cv.cvSet(sampleWeights,1.0) #compute priors (sample weights) priors = self.convertPriors(self.priors, self.trainData.domain.classVar) if type( priors ) == str: #If a string is returned, there was a failure, and it is the respective error mnessage. print priors return None #Train the model if self.verbose: self.printParams(params) classifier.train(mat, ml.CV_ROW_SAMPLE, responses, None, None, varTypes, missingDataMask, params, False, priors and str(priors).replace(",", " ") or None) return CvBoostClassifier(classifier=classifier, classVar=self.trainData.domain.classVar, imputeData=impData, verbose=self.verbose, varNames=CvMatrices["varNames"], nIter=None, basicStat=self.basicStat, NTrainEx=len(trainingData), parameters=self.parameters)
def __call__(self, trainingData, weight = None): """Creates an RF model from the data in trainingData. """ if not AZBaseClasses.AZLearner.__call__(self,trainingData, weight): return None # Set the number of theatd to be used ny opencv cv.cvSetNumThreads(max(int(self.NumThreads),0)) #Remove from the domain any unused values of discrete attributes including class trainingData = dataUtilities.getDataWithoutUnusedValues(trainingData,True) # Object holding the data req for predictions (model, domain, etc) #print time.asctime(), "=superRFmodel(trainingData.domain)" ##scPA # Remove meta attributes from training data #dataUtilities.rmAllMeta(trainingData) if len(trainingData.domain.getmetas()) == 0: trainData = trainingData else: trainData = dataUtilities.getCopyWithoutMeta(trainingData) # Impute the data and Convert the ExampleTable to CvMat if self.useBuiltInMissValHandling: #Create the imputer empty since we will not be using it impData = dataUtilities.DataTable(trainData.domain) CvMatrices = dataUtilities.ExampleTable2CvMat(trainData) else: #Create the imputer self.imputer = orange.ImputerConstructor_average(trainData) impData=self.imputer.defaults trainData = self.imputer(trainData) CvMatrices = dataUtilities.ExampleTable2CvMat(trainData) CvMatrices["missing_data_mask"] = None ##ecPA self.learner = ml.CvRTrees()#superRFmodel(trainData.domain) #This call creates a scratchDir # Set RF model parameter values # when nActVars defined as 0, use the sqrt of number of attributes so the user knows what will be used # This would be done in the C level if left as 0 if self.nActVars == "0" and len(trainData.domain.attributes)>0: self.nActVars = str(int(sqrt(len(trainData.domain.attributes)))) #print time.asctime(), "=self.setParameters" params = self.setParameters(trainData) # Print values of the parameters if self.verbose > 0: self.printOuts(params) #**************************************************************************************************// # Check for irrational input arguments #**************************************************************************************************// if params.min_sample_count >= len(trainingData): if self.verbose > 0: print "ERROR! Invalid minSample: ",params.min_sample_count if self.verbose > 0: print "minSample must be smaller than the number of examples." if self.verbose > 0: print "The number of examples is: ",len(trainingData) if len(trainingData) > 10: if self.verbose > 0: print "minSample assigned to default value: 10" params.min_sample_count = 10 else: if self.verbose > 0: print "Too few examples!!" if self.verbose > 0: print "Terminating" if self.verbose > 0: print "No random forest model built" return None if params.nactive_vars > len(trainingData.domain.attributes): if self.verbose > 0: print "ERROR! Invalid nActVars: ",params.nactive_vars if self.verbose > 0: print "nActVars must be smaller than or equal to the number of variables." if self.verbose > 0: print "The number of variables is: ", len(trainingData.domain.attributes) if self.verbose > 0: print "nActVars assigned to default value: sqrt(nVars)=",sqrt(len(trainingData.domain.attributes)) params.nactive_vars = 0; # Train RF model on data in openCVFile #print time.asctime(), "=Start Training" #Process the priors and Count the number of values in class var if trainingData.domain.classVar.varType == orange.VarTypes.Discrete: cls_count = len(trainData.domain.classVar.values) priors = self.convertPriors(self.priors,trainingData.domain.classVar) if type(priors) == str: #If a string is returned, there was a failure, and it is the respective error mnessage. print priors return None else: cls_count = 0 priors = None # Call the train method self.learner.train( CvMatrices["matrix"],ml.CV_ROW_SAMPLE,CvMatrices["responses"],None,None,CvMatrices["varTypes"],CvMatrices["missing_data_mask"],params,cls_count, priors and str(priors).replace(","," ") or None) if self.learner.get_var_importance(): varImportanceList = self.learner.get_var_importance() varImportance = {} varName = [] varImp = [] for idx,attr in enumerate(CvMatrices["varNames"]): varImportance[attr] = varImportanceList[idx] #Uncomment next lines if needed the outpuit already ordered #============================= begin ================================= # varName.append(attr) # varImp.append(varImportanceList[idx]) #Order the vars in terms of importance # insertion sort algorithm #for i in range(1, len(varImp)): # save = varImp[i] # saveName = varName[i] # j = i # while j > 0 and varImp[j - 1] < save: # varImp[j] = varImp[j - 1] # varName[j] = varName[j - 1] # j -= 1 # varImp[j] = save # varName[j] = saveName #For debug: test if assign var importance was correct #for attr in varImportance: # if varImportance[attr] != varImp[varName.index(attr)]: # print "ERROR: Variable importance of ", attr, " is not correct!" #OrderedVarImportance = {"VarNames":varName, "VarImportance":varImp} #============================= end ================================= else: varImportance = {} #print time.asctime(), "=Done" # Save info about the variables used in the model (used by the write method) #attributeInfo = dataUtilities.DataTable(trainData.domain) # place the impute data as the first example of this data #attributeInfo.append(self.imputer.defaults) return RFClassifier(classifier = self.learner, classVar = impData.domain.classVar, imputeData=impData, verbose = self.verbose, varNames = CvMatrices["varNames"],thisVer=True,useBuiltInMissValHandling = self.useBuiltInMissValHandling, varImportance = varImportance, basicStat = self.basicStat, NTrainEx = len(trainingData), parameters = self.parameters)
def __call__(self, data, weight=None): bestSeed = None bestAcc = None bestNiter = None bestModel = None #fix self.nDiffIniWeights for the disabled mode if self.nDiffIniWeights <= 1: self.nDiffIniWeights = 1 #loop over n different initial weights Disabled #Fix self.stopUPs for the disabled mode if self.stopUPs <= 0: self.stopUPs = 0 # Optimization of nIter will be disabled self.NTrainEx = len(data) #Remove from the domain any unused values of discrete attributes including class data = dataUtilities.getDataWithoutUnusedValues(data, True) #dataUtilities.rmAllMeta(data) if len(data.domain.getmetas()) == 0: cleanedData = data else: cleanedData = dataUtilities.getCopyWithoutMeta(data) # Create the imputer self.imputer = orange.ImputerConstructor_average(cleanedData) # Impute the data self.trainData = self.imputer(cleanedData) # If we are not seetin neither weights init optimization or nEphocs optimization (opencvLayer), the do nto split the data if self.stopUPs != 0 or self.nDiffIniWeights > 1: #Define train-80% and validation set-20% of the input data indices = orange.MakeRandomIndices2( p0=0.2, stratified=orange.MakeRandomIndices.StratifiedIfPossible) ind = indices(cleanedData) self.trainData = cleanedData.select(ind, 1) validationSet = cleanedData.select(ind, 0) else: validationSet = None if self.verbose and self.nDiffIniWeights > 1: print "=========== Training ", self.nDiffIniWeights, " times with different initial weights ==============" for n in range(self.nDiffIniWeights): if self.nDiffIniWeights <= 1: seed = 0 #in opencv mmlann seed=0 means the seed is disabled, and original seed will be used else: seed = len(cleanedData) * len(cleanedData.domain) * ( n + 1) #seed can be any integer #Create a model with a specific seed for training opencv ANN. #Also passing the step for the nIter optimization (self.stopUPs=0 - disable nIter optimization) #Also passing the validation set to be used in internal opencv implemented nEphocs optimization. model = self.__train__(weight=None, seed=seed, validationSet=validationSet) #Skip evaluation if the weights loop is disabled if self.nDiffIniWeights <= 1: return model break if cleanedData.domain.classVar.varType == orange.VarTypes.Discrete: Acc = evalUtilities.getClassificationAccuracy( validationSet, model) else: Acc = -evalUtilities.getRMSE(validationSet, model) if bestModel == None or (Acc > bestAcc) or ( Acc == bestAcc and model.nIter < bestNiter): bestSeed = seed bestAcc = Acc bestNiter = model.nIter bestModel = model if self.verbose: print "nIter:%-7s Acc:%-20s seed: %s" % (model.nIter, Acc, seed) if self.verbose: print "================ Best model Found: ===================" if self.verbose: print "nIter:%-7s Acc:%-20s seed: %s" % (bestNiter, bestAcc, bestSeed) # DEBUG for check if the returned model is indeed the best model, and not the last trainted #if cleanedData.domain.classVar.varType == orange.VarTypes.Discrete: # Acc = evalUtilities.getClassificationAccuracy(validationSet, bestModel) #else: # Acc = -evalUtilities.getRMSE(validationSet, bestModel) #if self.verbose: print "================ Best model returned: ===================" #if self.verbose: print "nIter:%-7s Acc:%-20s seed: %s" % (bestModel.nIter,Acc,bestModel.seed) return bestModel
def no_test_Impute(self): # Bayes cannot deal with regression """Test missing values imputation Assure that imputation works for the Bayes models. Test on data with missing values """ #This data is loaded here to speed up the test suite since it is too big contTestDataPath = os.path.join(AZOC.AZORANGEHOME, "tests/source/data/linearTest.tab") contTrainDataPath = os.path.join(AZOC.AZORANGEHOME, "tests/source/data/linearTrain.tab") contTrain = dataUtilities.DataTable(contTrainDataPath) contTest = dataUtilities.DataTable(contTestDataPath) ex1 = contTest[5] ex2 = contTest[6] self.assert_(ex1["Desc 71"] != "?", "The var Desc 71 shouldn't be missing!") self.assert_(ex2["Desc 138"] != "?", "The var Desc 138 shouldn't be missing!") imputer = orange.ImputerConstructor_average(contTrain) CvBayeslearner = AZorngCvBayes.CvBayesLearner() Bayes = CvBayeslearner(contTrain) # Prediction for data as it is P1 = Bayes(ex1) P2 = Bayes(ex2) # Predictions changing one continuous and one discrete variable to 0 ex1["Desc 71"] = 0 ex2["Desc 138"] = 0 P1_0 = Bayes(ex1) P2_0 = Bayes(ex2) # Predictions changing the same continuous and discrete variable to it's correspondent imputation value ex1["Desc 71"] = imputer.defaults["Desc 71"] ex2["Desc 138"] = imputer.defaults["Desc 138"] P1_imp = Bayes(ex1) P2_imp = Bayes(ex2) # Predictions changing the same continuous and discrete variable to '?' wich means that the same imputation # as in the last case will have to be made inside the classifier. So, the predicted value must be the same ex1["Desc 71"] = "?" ex2["Desc 138"] = "?" self.assert_(ex1["Desc 71"] == "?", "The var Desc 71 should be missing now!") self.assert_(ex2["Desc 138"] == "?", "The var Desc 138 should be missing now!") P1Miss = Bayes(ex1) P2Miss = Bayes(ex2) # Test if the prediction made for the example with mising value is the same as the one # for the example which missing values were substituted using the same method as the classifier does. self.assert_( P1_imp == P1Miss, "Imputation was not made correctly inside the classifier") #self.assert_(P2_imp==P2Miss,"Imputation was not made correctly inside the classifier") # Assure that if other substitutions on those variables were made, the predicted value would be different, # and so, this is a valid method for testing the imputation self.assert_( P1.value != P2.value) # Just to assure that we are not comaring equal examples self.assert_( P1.value != P1_imp.value, "The imputed 1 was the same as the original ... try other example") self.assert_( P1_0.value != P1_imp.value, "The imputed 1 was the same as the replaced by 0. The classifier may be replacing missing values by 0" ) self.assert_( P2.value != P2Miss.value, "The missing imputed 2 was the same as the original ... try other example" ) self.assert_( P2_0.value != P2Miss.value, "The missing imputed 2 was the same as the replaced by 0. The classifier may be replacing missing values by 0" ) #Test the imputer for saved models # Save the model scratchdir = os.path.join(AZOC.SCRATCHDIR, "scratchdir" + str(time.time())) os.mkdir(scratchdir) modelPath = os.path.join(scratchdir, "CvBayesModel") Bayes.write(modelPath) # Read in the model BayesM = AZorngCvBayes.CvBayesread(modelPath) # Predict the ex1 and ex2 which are still the examples with missing values '?' self.assert_(ex1["Desc 71"] == "?", "Value of Var Desc 71 should be missing!") self.assert_(ex2["Desc 138"] == "?", "Value of Var Desc 138 should be missing!") self.assert_( round(BayesM(ex1), 6) == round(P1Miss, 6), "Imputation on loaded model is not correct") self.assert_( round(BayesM(ex2), 6) == round(P2Miss, 6), "Imputation on loaded model is not correct") # Remove the scratch directory os.system("/bin/rm -rf " + scratchdir)
def testImpute(self): """Test missing values imputation Assure that imputation works for the pls models. Test on data with missing values """ ex1 = self.trainImpData[0] ex2 = self.trainImpData[3] self.assert_(ex1["DiscAttr2"] != "?", "The var DiscAttr2 shouldn't be missing!") self.assert_(ex2["Level"] != "?", "The var Level shouldn't be missing!") imputer = orange.ImputerConstructor_average(self.trainImpData) pls = AZorngPLS.PLSLearner(self.trainImpData) # Prediction for data as it is P1 = pls(ex1) P2 = pls(ex2) # Predictions changing one continuous and one discrete variable to 0 ex1["DiscAttr2"] = 0 ex2["Level"] = 0 P1_0 = pls(ex1) P2_0 = pls(ex2) # Predictions changing the same continuous and discrete variable to it's correspondent imputation value ex1["DiscAttr2"] = imputer.defaults["DiscAttr2"] ex2["Level"] = imputer.defaults["Level"] P1_imp = pls(ex1) P2_imp = pls(ex2) # Predictions changing the same continuous and discrete variable to '?' wich means that the same imputation # as in the last case will have to be made inside the classifier. So, the predicted value must be the same ex1["DiscAttr2"] = "?" ex2["Level"] = "?" self.assert_(ex1["DiscAttr2"] == "?", "The var DiscAttr2 should be missing now!") self.assert_(ex2["Level"] == "?", "The var Level should be missing now!") P1Miss = pls(ex1) P2Miss = pls(ex2) # Test if the prediction made for the example with mising value is the same as the one # for the example which missing values were substituted using the same method as the classifier does. self.assert_( P1_imp == P1Miss, "Imputation was not made correctly inside the classifier") self.assert_( P2_imp == P2Miss, "Imputation was not made correctly inside the classifier") # Assure that if other substitutions on those variables were made, the predicted value would be different, # and so, this is a valid method for testing the imputation self.assert_( P1.value != P2.value) # Just to assure that we are not comaring equal examples self.assert_(P1.value != P1_imp.value) self.assert_(P1_0.value != P1_imp.value) self.assert_(P2.value != P2_imp.value) self.assert_(P2_0.value != P2_imp.value) #Test the imputer for saved models # Save the model scratchdir = os.path.join(AZOC.SCRATCHDIR, "scratchdir" + str(time.time())) os.mkdir(scratchdir) modelPath = os.path.join(scratchdir, "PLSModel") pls.write(modelPath) # Read in the model plsM = AZorngPLS.PLSread(modelPath) # Predict the ex1 and ex2 which are still the examples with missing values '?' self.assert_(ex1["DiscAttr2"] == "?", "Value of Var DiscAttr2 should be missing!") self.assert_(ex2["Level"] == "?", "Value of Var Level should be missing!") self.assert_( plsM(ex1) == P1Miss, "Imputation on loaded model is not correct") self.assert_( plsM(ex2) == P2Miss, "Imputation on loaded model is not correct") # Remove the scratch directory os.system("/bin/rm -rf " + scratchdir)
def createInvCovMat(data, TSDT_file=None, C_file=None, SQRTICM_file=None, MTD_file=None): """ Inputs: data - The train data orange table Outputs (all in numpy format: .npy) *Not used* ICM_file - Path to save the Invertec Covariance Matrix TSDT_file - Path to save the TrainSet Data Table C_file - Path to save the Center file SQRTICM_file - Path to save the Sqrt Inverted Covariance Matrix MTD_file - Path to save the Mahalanobis Transformed Data """ from AZutilities import similarityMetrics import orange if data.hasMissingValues(): averageImputer = orange.ImputerConstructor_average(data) data = averageImputer(data) training_set = similarityMetrics.getTrainingSet(data) center = numpy.average(training_set.data_table, 0) # BackCompatibility ONLY. TODO: To Remove when mahalanobis is updated if SQRTICM_file: ICM_file = os.path.join( os.path.split(SQRTICM_file)[0], "invCovMatrix.npy") covarMat = numpy.cov(numpy.asarray(training_set.data_table), rowvar=0) inverse_covarMat = numpy.linalg.pinv(covarMat, rcond=1e-10) numpy.save(ICM_file, inverse_covarMat) if TSDT_file: numpy.save(TSDT_file, training_set.data_table) if C_file: numpy.save(C_file, center) # Next call to createMahalanobisData.sh is to be removed when the sqrtm(CI) is working. #Thisis known to be working in python 2.7 - Numpy - scipy # not yet solve on module numpy/python2.7-64_1.6.0 (python/64_2.7.1) status, out = commands.getstatusoutput( "env -i $AZORANGEHOME/azorange/AZutilities/createMahalanobisData.sh " + TSDT_file + " " + C_file + " " + SQRTICM_file + " " + MTD_file) if status: print "Error running Advanced Files creator: " + str(out) return False else: return True #Code runned at the momment by createMahalanobisData.sh using another version of python # (python2.7 locally installed in azorangeLive home directory) print "Creating advanced files" from scipy.linalg import sqrtm data = numpy.load(TSDT_file) center = numpy.load(C_file) m = numpy.mean(data, axis=0) data -= center print " Covariance matrix..." C = numpy.cov(numpy.transpose(data)) print "Inverse Covariance matrix..." CI = numpy.linalg.pinv(C, rcond=1e-10) print "Square Root Inverse Covariance matrix..." print CI SQI = sqrtm(CI).real print "Save Square Root Inverse Covariance matrix..." numpy.save(SQRTICM_file, SQI) print "Transforming..." MT = numpy.dot(data, SQI.T) # mahalanobis transformed data print " Saving Mahalanobis Transformed Data..." numpy.save(MTD_file, MT) return True
def __call__(self, examples, weight=0): # next function changes data set to a extended with unknown values def createLogRegExampleTable(data, weightID): finalData = orange.ExampleTable(data) origData = orange.ExampleTable(data) for at in data.domain.attributes: # za vsak atribut kreiraj nov newExampleTable newData # v dataOrig, dataFinal in newData dodaj nov atribut -- continuous variable if at.varType == orange.VarTypes.Continuous: atDisc = orange.FloatVariable(at.name + "Disc") newDomain = orange.Domain(origData.domain.attributes + [atDisc, data.domain.classVar]) newDomain.addmetas(newData.domain.getmetas()) finalData = orange.ExampleTable(newDomain, finalData) newData = orange.ExampleTable(newDomain, origData) origData = orange.ExampleTable(newDomain, origData) for d in origData: d[atDisc] = 0 for d in finalData: d[atDisc] = 0 for i, d in enumerate(newData): d[atDisc] = 1 d[at] = 0 d[weightID] = 100 * data[i][weightID] elif at.varType == orange.VarTypes.Discrete: # v dataOrig, dataFinal in newData atributu "at" dodaj ee eno vreednost, ki ima vrednost kar ime atributa + "X" atNew = orange.EnumVariable(at.name, values=at.values + [at.name + "X"]) newDomain = orange.Domain( filter(lambda x: x != at, origData.domain.attributes) + [atNew, origData.domain.classVar]) newDomain.addmetas(origData.domain.getmetas()) temp_finalData = orange.ExampleTable(finalData) finalData = orange.ExampleTable(newDomain, finalData) newData = orange.ExampleTable(newDomain, origData) temp_origData = orange.ExampleTable(origData) origData = orange.ExampleTable(newDomain, origData) for i, d in enumerate(origData): d[atNew] = temp_origData[i][at] for i, d in enumerate(finalData): d[atNew] = temp_finalData[i][at] for i, d in enumerate(newData): d[atNew] = at.name + "X" d[weightID] = 10 * data[i][weightID] finalData.extend(newData) return finalData learner = LogRegLearner(imputer=orange.ImputerConstructor_average(), removeSingular=self.removeSingular) # get Original Model orig_model = learner(examples, weight) # get extended Model (you should not change data) if weight == 0: weight = orange.newmetaid() examples.addMetaAttribute(weight, 1.0) extended_examples = createLogRegExampleTable(examples, weight) extended_model = learner(extended_examples, weight) ## print examples[0] ## printOUT(orig_model) ## print orig_model.domain ## print orig_model.beta ## printOUT(extended_model) # izracunas odstopanja # get sum of all betas beta = 0 betas_ap = [] for m in extended_models: beta_add = m.beta[m.continuizedDomain.attributes[-1]] betas_ap.append(beta_add) beta = beta + beta_add # substract it from intercept #print "beta", beta logistic_prior = orig_model.beta[0] + beta # compare it to bayes prior bayes = orange.BayesLearner(examples) bayes_prior = math.log(bayes.distribution[1] / bayes.distribution[0]) # normalize errors #print "bayes", bayes_prior #print "lr", orig_model.beta[0] #print "lr2", logistic_prior #print "dist", orange.Distribution(examples.domain.classVar,examples) k = (bayes_prior - orig_model.beta[0]) / (logistic_prior - orig_model.beta[0]) #print "prej", betas_ap betas_ap = [k * x for x in betas_ap] #print "potem", betas_ap # vrni originalni model in pripadajoce apriorne niclele return (orig_model, betas_ap)
def defaultImputer(dataset): """Default imputer with average data imputaton.""" return orange.ImputerConstructor_average(dataset)
def __call__(self, trainingData, weight=None): """Creates an PLS model from the data in trainingData. """ if not AZBaseClasses.AZLearner.__call__(self, trainingData, weight): return None #Remove from the domain any unused values of discrete attributes including class trainingData = dataUtilities.getDataWithoutUnusedValues( trainingData, True) # Create path for the Orange data scratchdir = miscUtilities.createScratchDir(desc="PLS") OrngFile = os.path.join(scratchdir, "OrngData.tab") # Remove meta attributes from training data to make the imputer work with examples without the meta attributes. #dataUtilities.rmAllMeta(trainingData) if len(trainingData.domain.getmetas()) == 0: trainData = trainingData else: trainData = dataUtilities.getCopyWithoutMeta(trainingData) # Create the imputer self.imputer = orange.ImputerConstructor_average(trainData) # Impute the data trainData = self.imputer(trainData) # Save the Data already imputed to an Orange formated file if self.verbose > 1: print time.asctime(), "Saving Orange Data to a tab file..." orange.saveTabDelimited(OrngFile, trainData) if self.verbose > 1: print time.asctime(), "done" # Create the PLS instance if self.verbose > 1: print time.asctime(), "Creating PLS Object..." learner = pls.PlsAPI() if self.verbose > 1: print time.asctime(), "done" # Assign the PLS parameters learner.SetParameter('v', str(self.verbose)) learner.SetParameter('debug', str(int(self.verbose > 0))) learner.SetParameter('method', self.method) if types.IntType(self.k) > len(trainData.domain.attributes): learner.SetParameter('k', str(len(trainData.domain.attributes))) if self.verbose > 0: print "Warning! The number of components were more than the number of attributes." if self.verbose > 0: print " Components were set to ", len( trainData.domain.attributes) else: learner.SetParameter('k', self.k) learner.SetParameter('precision', self.precision) learner.SetParameter('sDir', scratchdir) #AZOC.SCRATCHDIR) # Read the Orange Formated file and Train the Algorithm # TRAIN if self.verbose > 1: print time.asctime(), "Training..." learner.Train(OrngFile) if self.verbose > 1: print "Train finished at ", time.asctime() print "PLS trained in: " + str( learner.GetCPUTrainTime()) + " seconds" print "Method: " + learner.GetParameter("method") print "Components: " + learner.GetParameter("k") print "Precision: " + learner.GetParameter("precision") # Remove the scratch file if self.verbose == 0: miscUtilities.removeDir(scratchdir) else: print "The directory " + scratchdir + " was not deleted because DEBUG flag is ON" del trainData impData = self.imputer.defaults return PLSClassifier( classifier=learner, name="Classifier of " + self.name, classVar=trainingData.domain.classVar, imputeData=impData, verbose=self.verbose, varNames=[attr.name for attr in trainingData.domain.attributes], NTrainEx=len(trainingData), basicStat=self.basicStat, parameters=self.parameters) #learner.GetClassVarName())#