def treePerformanceEval(self, datain, dataout): #testin testout
for numtree, extree in enumerate(self.treeList):
#extree.scoreTree(datain, dataout)
#print("-----------------------------------------------")
print("Evaluating of tree #{}:".format(numtree + 1))
# test on train data
resultData = extree.predictTree(datain)
#for predict
unknownData = [] # futurelist = []
restlist = datain[
-self.window:] # predictionsize depends on window size
for num, x in enumerate(restlist):
unknownData.append(extree.predictTree(x.reshape(1, -1)))
unknownData = dtu.toListFromLArr(unknownData)
dataOutput = self.allData[2]
unknownX = np.arange(
len(dataOutput) - 1,
len(dataOutput) + self.window) # -1 for connection
unknownData.insert(
0, resultData[-1]
) # insert last element from resultTrainTest to unknown first pos
resultDataX = np.arange(
len(dataOutput) - len(resultData), len(dataOutput))
plotlistNN = [
[resultDataX, resultData, 'go-', 1.0,
1.0], #[resultDataX, dataout, 'co-', 1.0, 1.0]
[unknownX, unknownData, 'ro-', 1.0, 1.0],
[dataOutput, 'bo-', 0.5, 1.0]
]
legendlistNN = ['Result Test data', 'Predicted data',
"All data"] #'Actual test data'
dtu.buildGraph(
"Results of regression tree #{}".format(numtree + 1), True,
['Days', 'Price, NOK'], plotlistNN, legendlistNN)
dtu.analyzeResult(resultData, dataout, "test dataset")
print("Ended evaluation of tree.")
def testNetOnData(self, testInData): #train or test data
resultDataArr = self.activateNet(testInData)
result = dtu.toListFromLArr(resultDataArr)
return result
def activateNet(self, npInput):
resultData = []
for num, input in enumerate(npInput):
result = self.net.activate(input)
resultData.append(result)
return dtu.toListFromLArr(resultData)
def netPerformanceEval(self, trainin, testin): # trainout testout
for numnet, exNet in enumerate(self.netList):
print("-----------------------------------------------")
print("Evaluating of net #{}:".format(numnet + 1))
# test on train data
resultTrainData = exNet.activateNet(trainin)
# test on test data
resultTestData = exNet.activateNet(testin)
# test day and week ahead
unknownData = [] # futurelist = []
restlist = testin[
-self.window:] #predictionsize depends on window size
for num, x in enumerate(restlist):
unknownData.append(exNet.net.activate(x))
unknownData = dtu.toListFromLArr(unknownData)
# minmax16.transform()
# -----------------------------------------------
# network = network.reset()
dataOutput = self.allData[2]
trainOut = self.allData[4]
#print(dataOutput[-self.testDays:])
#print(resultTestData)
#print("Length")
#print(len((dataOutput[-self.testDays:])))
#print(len(resultTestData))
#print (resultTestData)
resultTrainData = exNet.activateNet(trainin)
resultTestData = exNet.activateNet(testin)
dataOutput = self.allData[2]
#trainOut = self.allData[4]
#length = len(datalist1)
# print ("Length of evaluated error list is {}". format(length))
error = dtu.computeSimpleAvgErr(resultTestData,
dataOutput[-self.testDays:])
print("Error of actual and test data: {}".format(error))
unknownX = np.arange(
len(dataOutput) - 1,
len(dataOutput) + self.window) # -1 for connection
resultTrainTest = np.concatenate((resultTrainData, resultTestData),
axis=0)
unknownData.insert(
0, resultTrainTest[-1]
) #insert last element from resultTrainTest to unknown first pos
# print (len(unknownData), len(unknownX))
plotlistNN = [[dataOutput, 'go-', 1.0, 1.0],
[resultTrainTest, 'bo-', 1.0, 1.0],
[unknownX, unknownData, 'ro-', 1.0, 1.0]]
legendlistNN = [
'All output data', 'Train and test data', 'Predicted data'
]
dtu.buildGraph("Results of BP ANN (DFF)#{}".format(numnet + 1),
True, ['Days', 'Price, NOK'], plotlistNN,
legendlistNN)
dtu.analyzeResult(resultTrainTest, dataOutput, "All data")
#for ensembling
exNet.predictedVals = unknownData
exNet.predictedX = unknownX
exNet.resultTrainVals = resultTrainTest
print("Ended evaluation of net.")
print("-----------------------------------------------")