def test_SVMC(self):
# Train a svm
svmL = AZorngCvSVM.CvSVMLearner(scaleData=False,
svm_type=103,
gamma=0.01,
C=1,
nu=0.5,
p=1,
eps=0.001,
coef0=0,
degree=3)
svm = svmL(self.inDataC)
trainedAcc = evalUtilities.getRMSE(self.inDataC, svm)
self.assertEqual(round(trainedAcc, 7), round(2.8525863999999999,
7)) # ver 0.3
# Save model
rc = svm.write(self.modelPath)
self.assertEqual(rc, True)
# Load the saved model
loadedsvm = AZorngCvSVM.CvSVMread(self.modelPath)
loadedAcc = evalUtilities.getRMSE(self.inDataC, loadedsvm)
# Assure equal accuracy
self.assertEqual(trainedAcc, loadedAcc)
svmLearner = AZorngCvSVM.CvSVMLearner(scaleData=False)
svmLearner.name = "CvSVMLearner"
svmLearner.eps = 0.001
svmLearner.p = 1
svmLearner.nu = 0.6
svmLearner.kernel_type = 2
svmLearner.svm_type = 103
svmLearner.gamma = 0.0033
svmLearner.C = 47
svmLearner.scaleData = True
svmLearner.scaleClass = False
Res = orngTest.crossValidation(
[svmLearner],
self.inDataC,
folds=5,
strat=orange.MakeRandomIndices.StratifiedIfPossible)
RMSE = evalUtilities.RMSE(Res)[0]
self.assertEqual(round(RMSE, 2), round(2.96, 2)) #Ver 0.3
newSVM = svmLearner(self.inDataC)
trainedAcc = evalUtilities.getRMSE(self.inDataC, newSVM)
# Save model
rc = newSVM.write(self.modelPath)
self.assertEqual(rc, True)
# Load the saved model
loadedsvm = AZorngCvSVM.CvSVMread(self.modelPath)
loadedAcc = evalUtilities.getRMSE(self.inDataC, loadedsvm)
# Assure equal accuracy
self.assertEqual(round(trainedAcc, 4), round(2.8289, 4)) #Ver 0.3
self.assertEqual(round(trainedAcc, 4), round(loadedAcc, 4))
def test_SVMC(self):
# Train a svm
svmL = AZorngCvSVM.CvSVMLearner(
scaleData=False, svm_type=103, gamma=0.01, C=1, nu=0.5, p=1, eps=0.001, coef0=0, degree=3
)
svm = svmL(self.inDataC)
trainedAcc = evalUtilities.getRMSE(self.inDataC, svm)
self.assertEqual(round(trainedAcc, 7), round(2.8525863999999999, 7)) # ver 0.3
# Save model
rc = svm.write(self.modelPath)
self.assertEqual(rc, True)
# Load the saved model
loadedsvm = AZorngCvSVM.CvSVMread(self.modelPath)
loadedAcc = evalUtilities.getRMSE(self.inDataC, loadedsvm)
# Assure equal accuracy
self.assertEqual(trainedAcc, loadedAcc)
svmLearner = AZorngCvSVM.CvSVMLearner(scaleData=False)
svmLearner.name = "CvSVMLearner"
svmLearner.eps = 0.001
svmLearner.p = 1
svmLearner.nu = 0.6
svmLearner.kernel_type = 2
svmLearner.svm_type = 103
svmLearner.gamma = 0.0033
svmLearner.C = 47
svmLearner.scaleData = True
svmLearner.scaleClass = False
Res = orngTest.crossValidation(
[svmLearner], self.inDataC, folds=5, strat=orange.MakeRandomIndices.StratifiedIfPossible
)
RMSE = evalUtilities.RMSE(Res)[0]
self.assertEqual(round(RMSE, 2), round(2.96, 2)) # Ver 0.3
newSVM = svmLearner(self.inDataC)
trainedAcc = evalUtilities.getRMSE(self.inDataC, newSVM)
# Save model
rc = newSVM.write(self.modelPath)
self.assertEqual(rc, True)
# Load the saved model
loadedsvm = AZorngCvSVM.CvSVMread(self.modelPath)
loadedAcc = evalUtilities.getRMSE(self.inDataC, loadedsvm)
# Assure equal accuracy
self.assertEqual(round(trainedAcc, 4), round(2.8289, 4)) # Ver 0.3
self.assertEqual(round(trainedAcc, 4), round(loadedAcc, 4))
def testgetRMSE(self):
data = dataUtilities.DataTable(self.regDataPath)
RFlearner = AZorngRF.RFLearner()
trainData = data[0:int(len(data)/2)]
testData = data[int(len(data)/2)+1:]
classifier = RFlearner(data)
RMSE = evalUtilities.getRMSE(testData,classifier)
self.assert_(RMSE-2.07396535555 < 0.05, "Got:"+str(RMSE))
def testgetRMSE(self):
data = dataUtilities.DataTable(self.regDataPath)
RFlearner = AZorngRF.RFLearner()
trainData = data[0:int(len(data) / 2)]
testData = data[int(len(data) / 2) + 1:]
classifier = RFlearner(data)
RMSE = evalUtilities.getRMSE(testData, classifier)
self.assert_(RMSE - 2.07396535555 < 0.05, "Got:" + str(RMSE))
def test_RFRegression(self):
"""RF - Test of optimizer with continuous class data
"""
#Create the appspack instance
opt=paramOptUtilities.Appspack()
#Learner to be optimized
learner=AZorngRF.RFLearner()
#dataset to use in the parameters optimization (Discrete class in this example)
dataSet=self.contTrainDataPath
# Define the objective function. This requires:
# defining the extreme to find (the min or max): findMin=True or findMin=False
fMin=True
# defining the method for evaluation (must be a method that accepts as input an orngTest.ExperimentResults):
# evaluateMethod="AZutilities.evalUtilities.R2"
evalM="AZutilities.evalUtilities.RMSE"
# Create an interface for setting optimizer parameters
pars = AZLearnersParamsConfig.API("RFLearner")
# Set the parameters in parameterList to be optimized
pars.setParameter("NumThreads","optimize",False)
# Change the default
pars.setParameter("NumThreads","default","1")
# Create a directory for running the appspack (if not defined it will use the present working directory)
runPath = miscUtilities.createScratchDir(desc="ParamOptTest")
# Run the appspack which will configure the input learner and aditionaly return
#[<minimum of objective function found>, <optimized parameters>]
tunedPars = opt(learner=learner,\
dataSet=dataSet,\
evaluateMethod = evalM,\
findMin=fMin,\
runPath = runPath,\
useStd = False,\
useParameters = pars.getParametersDict(),\
verbose = 0)
print "Returned: ", tunedPars
print "====================== optimization Done ==========================="
print "Learner optimized flag = ", learner.optimized
print "Tuned parameters = ", tunedPars[1]
print "Best optimization result = ", tunedPars[0]
print "check the file intRes.txt to see the intermediate results of optimizer!"
self.assertEqual(opt.usedMPI,False)
self.assertEqual(learner.optimized,True)
self.assertEqual(round(tunedPars[0],2),round(3.1499999999999999,2))
#The learner is now with its optimized parameters already set, so we can now make a classifier out of it
classifier = learner(self.contTrain)
RMSE = evalUtilities.getRMSE(self.contTest,classifier)
self.assertEqual(round(RMSE,2),round(2.02,2)) #Ver 0.3
#Check if the best result was not the one with numThreads different of 1 since that way we can get
#different results among runs
self.assertEqual(int(tunedPars[1]["NumThreads"]),1)
miscUtilities.removeDir(runPath)
def test_RFRegression(self):
"""RF - Test of optimizer with continuous class data
"""
#Create the appspack instance
opt = paramOptUtilities.Appspack()
#Learner to be optimized
learner = AZorngRF.RFLearner()
#dataset to use in the parameters optimization (Discrete class in this example)
dataSet = self.contTrainDataPath
# Define the objective function. This requires:
# defining the extreme to find (the min or max): findMin=True or findMin=False
fMin = True
# defining the method for evaluation (must be a method that accepts as input an orngTest.ExperimentResults):
# evaluateMethod="AZutilities.evalUtilities.R2"
evalM = "AZutilities.evalUtilities.RMSE"
# Create an interface for setting optimizer parameters
pars = AZLearnersParamsConfig.API("RFLearner")
# Set the parameters in parameterList to be optimized
pars.setParameter("NumThreads", "optimize", False)
# Change the default
pars.setParameter("NumThreads", "default", "1")
# Create a directory for running the appspack (if not defined it will use the present working directory)
runPath = miscUtilities.createScratchDir(desc="ParamOptTest")
# Run the appspack which will configure the input learner and aditionaly return
#[<minimum of objective function found>, <optimized parameters>]
tunedPars = opt(learner=learner,\
dataSet=dataSet,\
evaluateMethod = evalM,\
findMin=fMin,\
runPath = runPath,\
useStd = False,\
useParameters = pars.getParametersDict(),\
verbose = 0)
print "Returned: ", tunedPars
print "====================== optimization Done ==========================="
print "Learner optimized flag = ", learner.optimized
print "Tuned parameters = ", tunedPars[1]
print "Best optimization result = ", tunedPars[0]
print "check the file intRes.txt to see the intermediate results of optimizer!"
self.assertEqual(opt.usedMPI, False)
self.assertEqual(learner.optimized, True)
self.assertEqual(round(tunedPars[0], 2), round(3.1499999999999999, 2))
#The learner is now with its optimized parameters already set, so we can now make a classifier out of it
classifier = learner(self.contTrain)
RMSE = evalUtilities.getRMSE(self.contTest, classifier)
self.assertEqual(round(RMSE, 2), round(2.02, 2)) #Ver 0.3
#Check if the best result was not the one with numThreads different of 1 since that way we can get
#different results among runs
self.assertEqual(int(tunedPars[1]["NumThreads"]), 1)
miscUtilities.removeDir(runPath)
def testPersistentRegAcc(self):
"""Test the persistence of the learner as Regressor
Assure that the RMSE is perserved for models trained in the same way.
"""
PLSlearner = AZorngPLS.PLSLearner(k="3", method="simpls", precision="1e-6")
PLSRegressor = PLSlearner(self.contTrain)
# Calculate RMSE
RegressorRMSE = evalUtilities.getRMSE(self.contTest, PLSRegressor)
# Check that RMSE is what it used to be
self.assertEqual(round(0.67276457999999995,8),round(RegressorRMSE,8))
def testPersistentRegAcc(self):
"""Test the persistence of the learner as Regressor
Assure that the RMSE is perserved for models trained in the same way.
"""
PLSlearner = AZorngPLS.PLSLearner(k="3",
method="simpls",
precision="1e-6")
PLSRegressor = PLSlearner(self.contTrain)
# Calculate RMSE
RegressorRMSE = evalUtilities.getRMSE(self.contTest, PLSRegressor)
# Check that RMSE is what it used to be
self.assertEqual(round(4.39715452, 8), round(RegressorRMSE, 8))
def test_PersistentRegAcc(self):
"""
Assure that the accuracy is perserved for models trained in the same way.
"""
# Create a RF model
RFlearner = AZorngRF.RFLearner(NumThreads = 1, maxDepth = "20", minSample = "5", useSurrogates = "false", getVarVariance = "false", \
nActVars = "0", nTrees = "100", forestAcc = "0.1", termCrit = "0")
RFmodel = RFlearner(self.trainDataReg)
# Calculate classification accuracy
Acc = evalUtilities.getRMSE(self.testDataReg, RFmodel)
# Check that the accuracy is what it used to be
self.assertEqual(round(2.0158,5),round(Acc,5)) #opencv1.1: 0.32984999999999998,5
def test_RF_Regression(self):
"""RF - Test of optimizer with continuous class data
"""
expectedRes = [
3.27, 3.2599999999999998, 3.15
] #Ver 0.3 - Artifact: The second value can be expected on other Systems
#Create the appspack instance
opt = paramOptUtilities.Appspack()
#Learner to be optimized
learner = AZorngRF.RFLearner()
#dataset to use in the parameters optimization
dataSet = self.contTrainDataPath
# Define the objective function. This requires:
# defining the extreme to find (the min or max): findMin=True or findMin=False
fMin = True
# defining the method for evaluation (must be a method that accepts as input an orngTest.ExperimentResults):
# evaluateMethod="AZutilities.evalUtilities.R2"
evalM = "AZutilities.evalUtilities.RMSE"
# Create a directory for running the appspack (if not defined it will use the present working directory)
runPath = miscUtilities.createScratchDir(desc="ParamOptTest")
# Run the appspack which will configure the input learner and aditionaly return
#[<minimum of objective function found>, <optimized parameters>]
tunedPars = opt(learner=learner,\
dataSet=dataSet,\
evaluateMethod = evalM,\
findMin=fMin,\
runPath = runPath,\
useStd = False,\
verbose = 0)
print "Returned: ", tunedPars
print "====================== optimization Done ==========================="
print "Learner optimized flag = ", learner.optimized
print "Tuned parameters = ", tunedPars[1]
print "Best optimization result = ", tunedPars[0]
print "check the file intRes.txt to see the intermediate results of optimizer!"
self.assertEqual(opt.usedMPI, False)
self.assertEqual(learner.optimized, True)
self.assert_(
round(tunedPars[0], 2)
in [round(x, 2) for x in expectedRes]) #Ver 0.3
#The learner is now with its optimized parameters already set, so we can now make a classifier out of it
classifier = learner(self.contTrain)
RMSE = evalUtilities.getRMSE(self.contTest, classifier)
expectedRes = [2.89, 2.0158]
self.assert_(round(RMSE, 2)
in [round(x, 2) for x in expectedRes]) #Ver 0.3
miscUtilities.removeDir(runPath)
def test_PersistentRegAcc(self):
"""
Assure that the accuracy is perserved for models trained in the same way.
"""
# Create a RF model
RFlearner = AZorngRF.RFLearner(NumThreads = 1, maxDepth = "20", minSample = "5", useSurrogates = "false", getVarVariance = "false", \
nActVars = "0", nTrees = "100", forestAcc = "0.1", termCrit = "0")
RFmodel = RFlearner(self.trainDataReg)
# Calculate classification accuracy
Acc = evalUtilities.getRMSE(self.testDataReg, RFmodel)
# Check that the accuracy is what it used to be
self.assertEqual(round(2.0158, 5),
round(Acc, 5)) #opencv1.1: 0.32984999999999998,5
def test_PersistentRegAcc(self):
"""
Assure that the accuracy is perserved for models trained in the same way.
"""
#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)
# Create a CvANN model
CvANNlearner = AZorngCvANN.CvANNLearner(randomWeights = False, nHidden = [3], nEpochs = 100,stopUPs=0)
CvANNmodel = CvANNlearner(contTrain)
# Calculate classification accuracy
Acc = evalUtilities.getRMSE(contTest, CvANNmodel)
# Check that the accuracy is what it used to be
self.assertEqual(round(0.109667,6),round(Acc,6)) #opencv1.1: 0.168131
def test_PersistentRegAcc(self):
"""
Assure that the accuracy is perserved for models trained in the same way.
"""
#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)
# Create a CvANN model
CvANNlearner = AZorngCvANN.CvANNLearner(randomWeights = False, nHidden = [3], nEpochs = 100,stopUPs=0)
CvANNmodel = CvANNlearner(contTrain)
# Calculate classification accuracy
Acc = evalUtilities.getRMSE(contTest, CvANNmodel)
# Check that the accuracy is what it used to be
self.assertEqual(round(0.109667,6),round(Acc,6)) #opencv1.1: 0.168131
def test_PLS_Regression(self):
"""PLS - Test of optimizer with continuous class data
"""
expectedRes = [3.27, 3.2599999999999998] #Ver 0.3 - Artifact: The second value can be expected on other Systems
#Create the appspack instance
opt=paramOptUtilities.Appspack()
#Learner to be optimized
learner=AZorngPLS.PLSLearner()
#dataset to use in the parameters optimization
dataSet=self.contTrainDataPath
# Define the objective function. This requires:
# defining the extreme to find (the min or max): findMin=True or findMin=False
fMin=True
# defining the method for evaluation (must be a method that accepts as input an orngTest.ExperimentResults):
# evaluateMethod="AZutilities.evalUtilities.R2"
evalM="AZutilities.evalUtilities.RMSE"
# Create a directory for running the appspack (if not defined it will use the present working directory)
runPath = miscUtilities.createScratchDir(desc="ParamOptTest")
# Run the appspack which will configure the input learner and aditionaly return
#[<minimum of objective function found>, <optimized parameters>]
tunedPars = opt(learner=learner,\
dataSet=dataSet,\
evaluateMethod = evalM,\
findMin=fMin,\
runPath = runPath,\
useStd = False,\
verbose = 0)
print "Returned: ", tunedPars
print "====================== optimization Done ==========================="
print "Learner optimized flag = ", learner.optimized
print "Tuned parameters = ", tunedPars[1]
print "Best optimization result = ", tunedPars[0]
print "check the file intRes.txt to see the intermediate results of optimizer!"
self.assertEqual(opt.usedMPI,False)
self.assertEqual(learner.optimized,True)
self.assert_(round(tunedPars[0],2) in [round(x,2) for x in expectedRes]) #Ver 0.3
#The learner is now with its optimized parameters already set, so we can now make a classifier out of it
classifier = learner(self.contTrain)
RMSE = evalUtilities.getRMSE(self.contTest,classifier)
self.assertEqual(round(RMSE,2),round(2.8900000000000001,2)) #Ver 0.3
miscUtilities.removeDir(runPath)
def getAcc(self):
""" For regression problems, it returns the RMSE and the R2
For Classification problems, it returns CA and the ConfMat
The return is made in a Dict: {"RMSE":0.2,"R2":0.1,"CA":0.98,"CM":[[TP, FP],[FN,TN]]}
For the EvalResults not supported for a specific learner/datase, the respective result will be None
It some error occurred, the respective values in the Dict will be None
"""
if not self.__areInputsOK():
return None
res = {"RMSE":None,"R2":None,"CA":None,"CM":None}
# Set the response type
responseType = self.data.domain.classVar.varType == orange.VarTypes.Discrete and "Classification" or "Regression"
#Create the Train and test sets
DataIdxs = dataUtilities.SeedDataSampler(self.data, self.nExtFolds)
#Var for saving each Fols result
results = []
for foldN in range(self.nExtFolds):
trainData = self.data.select(DataIdxs[foldN],negate=1)
runPath = miscUtilities.createScratchDir(desc = "AccWOptParam")
trainData.save(os.path.join(runPath,"trainData.tab"))
testData = self.data.select(DataIdxs[foldN])
paramOptUtilities.optimizeSelectedParam(
learner = self.learner,
learnerName = self.learnerName,
trainDataFile = os.path.join(runPath,"trainData.tab"),
paramList = self.paramList,
responseType = responseType,
grid = False,
useGrid = False,
verbose = 0,
queueType = "batch.q",
runPath = runPath,
nExtFolds = None,
nFolds = self.nInnerFolds)
if not self.learner.optimized:
print "The learner was not optimized."
return None
miscUtilities.removeDir(runPath)
#Train the model
model = self.learner(trainData)
#Test teh model
if responseType == "Classification":
results.append((evalUtilities.getClassificationAccuracy(testData, model), evalUtilities.getConfMat(testData, model) ) )
else:
results.append((evalUtilities.getRMSE(testData, model), evalUtilities.getRsqrt(testData, model) ) )
#Calculate the average of results
#Compute the first result (CA or RMSE)
if responseType == "Classification":
resName = "CA"
else:
resName = "RMSE"
res[resName] = 0.0
for r in results:
res[resName] += r[0]
res[resName] = res[resName] / self.nExtFolds
#Compute the second result (ConfMat or R2)
if responseType == "Classification":
res["CM"] = results[0][1] # Get the first ConfMat
for r in results[1:]:
for Lidx,line in enumerate(r[1]):
for idx,val in enumerate(line):
res["CM"][Lidx][idx] = res["CM"][Lidx][idx] + val #Add each same ConfMat position
else:
res["R2"] = 0.0
for r in results:
res["R2"] += r[1]
res["R2"] = res["R2"] / self.nExtFolds
if self.verbose > 0: print "AccWOptParamGetter!Results: ",results, "\n res = ",res
return res
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
#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 __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
