def ClassificationResults(self, fullEval=False, needFuzzy=False):
"""
Method use for receiving results after activating Neuronet with all input vectors.
If fullEval = True then method calculate results for all input vectors, otherwise for first and last two input vectors.
if needFuzzy = True then appropriate output values converting into fuzzy values after activating, otherwise used real values.
"""
classificationResults = []
FCLogger.debug('Classification results: ')
if fullEval:
if needFuzzy:
for vector in self._rawData:
inputVector = vector[:self.config[0]]
expectedVector = vector[self.config[-1] + 1:]
classificationResults.append(
self.ClassificationResultForOneVector(
inputVector, expectedVector, needFuzzy))
else:
for vector in self._rawDefuzData:
inputVector = vector[:self.config[0]]
expectedVector = vector[self.config[-1] + 1:]
classificationResults.append(
self.ClassificationResultForOneVector(
inputVector, expectedVector))
else:
classificationResults.append(
self.ClassificationResultForOneVector(
self._rawData[0][:self.config[0]] if not needFuzzy else
self._rawDefuzData[0][:self.config[0]],
self._rawData[0][self.config[-1] + 1:] if not needFuzzy
else self._rawDefuzData[0][self.config[-1] + 1:],
needFuzzy))
classificationResults.append(
self.ClassificationResultForOneVector(
self._rawData[1][:self.config[0]] if not needFuzzy else
self._rawDefuzData[1][:self.config[0]],
self._rawData[1][self.config[-1] + 1:] if not needFuzzy
else self._rawDefuzData[1][self.config[-1] + 1:],
needFuzzy))
FCLogger.debug(' ... skipped ...')
classificationResults.append(
self.ClassificationResultForOneVector(
self._rawData[-2][:self.config[0]] if not needFuzzy else
self._rawDefuzData[-2][:self.config[0]],
self._rawData[-2][self.config[-1] + 1:] if not needFuzzy
else self._rawDefuzData[-2][self.config[-1] + 1:],
needFuzzy))
classificationResults.append(
self.ClassificationResultForOneVector(
self._rawData[-1][:self.config[0]] if not needFuzzy else
self._rawDefuzData[-1][:self.config[0]],
self._rawData[-1][self.config[-1] + 1:] if not needFuzzy
else self._rawDefuzData[-1][self.config[-1] + 1:],
needFuzzy))
return classificationResults
def rawData(self, value):
if isinstance(value, list):
self._rawData = value
else:
self._rawData = []
FCLogger.warning(
'Raw text data might be a list of strings! It was set to empty list: [].'
)
def rawData(self, value):
if isinstance(value, list):
self._rawData = value
else:
self._rawData = []
FCLogger.warning('Raw text data might be a list of strings! It was set to empty list: [].')
self._DefuzRawData()
def SaveNetwork(self):
"""
Creating dump of network.
"""
FCLogger.debug('Saving network to PyBrain xml-formatted file...')
NetworkWriter.writeToFile(self.network, self.networkFile)
FCLogger.info('Network saved to file: {}'.format(os.path.abspath(self.networkFile)))
def IsCorrectFuzzyNumberValue(value):
"""
All operations in fuzzy logic are executed with numbers in interval [0, 1].
"""
if IsNumber(value):
return (0. <= value) and (value <= 1.)
else:
FCLogger.error('{} not a real number in [0, 1], type = {}'.format(str(value), type(value)))
return False
def SaveNetwork(self):
"""
Creating dump of network.
"""
FCLogger.debug('Saving network to PyBrain xml-formatted file...')
NetworkWriter.writeToFile(self.network, self.networkFile)
FCLogger.info('Network saved to file: {}'.format(
os.path.abspath(self.networkFile)))
def ClassificationResultForOneVector(self, inputVector, expectedVector=None, needFuzzy=False):
"""
Method use for receiving results after activating Neuronet with one input vector.
inputVector - is a defuzzyficated raw data of input vector.
if needFuzzy = True then appropriate output values converting into fuzzy values after activating, otherwise used real values.
"""
# defuzzyficate input values:
defuzInput = []
for value in inputVector:
level = self.scale.GetLevelByName(levelName='{}'.format(value), exactMatching=False)
if level:
if isinstance(level['fSet'], FuzzySet):
defuzInput.append(level['fSet'].Defuz())
else:
defuzInput.append(value)
# defuzzyficate expected values:
defuzExpectedVector = []
for value in expectedVector:
level = self.scale.GetLevelByName(levelName='{}'.format(value), exactMatching=False)
if level:
if isinstance(level['fSet'], FuzzySet):
defuzExpectedVector.append(level['fSet'].Defuz())
else:
defuzExpectedVector.append(value)
outputVector = self.network.activate(defuzInput)
if expectedVector:
errorVector = []
for num, currentValue in enumerate(outputVector):
errorVector.append(float(defuzExpectedVector[num]) - currentValue)
else:
errorVector = None
if needFuzzy:
fuzzyOutputVector = []
for value in outputVector:
fuzzyOutputVector.append(self.scale.Fuzzy(value)['name'])
FCLogger.debug(' Input: {}\tOutput: {}{}'.format(
inputVector, fuzzyOutputVector, '\tExpected: {}'.format(expectedVector) if expectedVector else ''))
return inputVector, fuzzyOutputVector, expectedVector, errorVector
else:
FCLogger.debug(' Input: {}\tOutput: {}{}'.format(
defuzInput, outputVector, '\tExpected: {}\tError: {}'.format(defuzExpectedVector, errorVector) if expectedVector else ''))
return defuzInput, outputVector, defuzExpectedVector, errorVector
def SaveNetwork(self):
"""
Creating dump of network.
"""
FCLogger.debug(
'Autosaving - enabled. Trying to save network as PyBrain xml-formatted file...'
)
NetworkWriter.writeToFile(self.network, self.networkFile)
FCLogger.info('Current network saved to file: {}'.format(
os.path.abspath(self.networkFile)))
def epochs(self, value):
if isinstance(value, int):
if value >= 1:
self._epochs = value
else:
self._epochs = 1
FCLogger.warning('Parameter epochs might be greater or equal 1! It was set to 1 now.')
else:
self._epochs = 10
FCLogger.warning('Parameter epochs might be an integer number! It was set to 10, by default.')
def ignoreColumns(self, value):
if isinstance(value, list):
self._ignoreColumns = []
for el in value:
if not isinstance(el, int):
self._ignoreColumns = []
FCLogger.warning(
'Parameter ignoreColumns must be list of numbers! It was set to empty list, by default.'
)
break
else:
if el > 0:
self._ignoreColumns.append(el - 1)
FCLogger.debug(
'Column added to ignore list: {} (index: {})'.
format(el, el - 1))
else:
FCLogger.debug(
'Column {} (index: {}) not added to ignoreColumns list.'
.format(el, el - 1))
else:
self._ignoreColumns = []
FCLogger.warning(
'Parameter ignoreColumns must be list of numbers! It was set to empty list, by default.'
)
self._ignoreColumns = list(set(self._ignoreColumns))
def ignoreRows(self, value):
if isinstance(value, list):
self._ignoreRows = [0] # always ignore 1st header line
for el in value:
if not isinstance(el, int):
self._ignoreRows = [0]
FCLogger.warning(
'Parameter ignoreRows must be list of numbers! It was set to [0], by default.'
)
break
else:
if el > 0:
self._ignoreRows.append(el - 1)
FCLogger.debug(
'Row added to ignore list: {} (index: {})'.format(
el, el - 1))
else:
FCLogger.debug(
'Row {} (index: {}) not added to ignoreRows list.'.
format(el, el - 1))
else:
self._ignoreRows = [0]
FCLogger.warning(
'Parameter ignoreRows must be list of numbers! It was set to [0], by default.'
)
self._ignoreRows = list(set(self._ignoreRows))
def IsCorrectFuzzyNumberValue(value):
"""
All operations in fuzzy logic are executed with numbers in interval [0, 1].
"""
correctNumberFlag = True
try:
correctNumberFlag = (0 <= value <= 1)
except:
FCLogger.error('{} is number not in [0, 1]!')
correctNumberFlag = False
finally:
return correctNumberFlag
def IsCorrectFuzzyNumberValue(value):
"""
All operations in fuzzy logic are executed with numbers in interval [0, 1].
"""
correctNumberFlag = True
try:
correctNumberFlag = (0 <= value <= 1)
except:
FCLogger.error('{} is number not in [0, 1]!')
correctNumberFlag = False
finally:
return correctNumberFlag
def CreateReport(self, results=None, fuzzyOutput=True):
"""
Creating text report after classificate vector-candidates.
results is a list of tuples in ClassificationResults() format.
fuzzyOutput is a key for show fuzzy values if True.
"""
FCLogger.debug('Creating Classificate Report File...')
noReportCreationErrors = True # successful of Creating Report process flag
try:
if not results:
results = self.ClassificationResults(fullEval=True,
needFuzzy=fuzzyOutput)
with open(self.reportFile, 'w') as fH:
fH.write('Neuronet: {}\n\n'.format(
os.path.abspath(self.networkFile)))
fH.write('{}\n\n'.format(self.scale))
fH.write('Classification results for candidates vectors:\n\n')
head = ' Header: [{}]\t[{}]\n'.format(
' '.join(header
for header in self.headers[:self.config[0]]),
' '.join(header
for header in self.headers[len(self.headers) -
self.config[-1]:])
if len(self.headers) >= self.config[0] + self.config[-1]
else '')
fH.write(head)
fH.write(
' {}\n'.format('-' *
len(head) if len(head) < 100 else '-' *
100))
for result in results:
if fuzzyOutput:
fH.write(' Input: {}\tOutput: {}{}\n'.format(
result[0], result[1], '\tExpected: {}'.format(
result[2]) if result[2] else ''))
else:
fH.write(' Input: {}\tOutput: {}{}\n'.format(
result[0], result[1],
'\tExpected: {}\tError: {}'.format(
result[2], result[3]) if result[2] else ''))
FCLogger.info('Classificate Report File created: ' +
os.path.abspath(self.reportFile))
except:
noReportCreationErrors = False
FCLogger.error(traceback.format_exc())
FCLogger.error(
'An error occurred while Classificate Report creating!')
finally:
return noReportCreationErrors
def epochs(self, value):
if isinstance(value, int):
if value >= 0:
self._epochs = value
else:
self._epochs = 1
FCLogger.warning(
'Parameter epochs might be greater or equal 0! It was set to 1.'
)
else:
self._epochs = 10
FCLogger.warning(
'Parameter epochs might be an integer number! It was set to 10, by default.'
)
def stop(self, value):
if isinstance(value, float):
if (value >= 0) and (value <= 100):
self._stop = value
else:
self._stop = 0
FCLogger.warning(
'Parameter stop might be greater than 0 and less or equal 100! It was set to 0 now.'
)
else:
self._stop = 0
FCLogger.warning(
'Parameter stop might be a float number! It was set to 0, by default.'
)
def epochsToUpdate(self, value):
if isinstance(value, int):
if value >= 1:
self._epochsToUpdate = value
else:
self._epochsToUpdate = 1
FCLogger.warning(
'Parameter epochsToUpdate might be greater or equal 1! It was set to 1.'
)
else:
self._epochsToUpdate = 5
FCLogger.warning(
'Parameter epochs might be an integer number! It was set to 5, by default.'
)
def DiapasonParser(diapason):
"""
Parse input with diapason string and return sorted list of full and unique indexes in that diapason.
Examples:
String "1,5" converted to: [1, 5]
String "1-5" converted to: [1, 2, 3, 4, 5]
String "8-10, 1-5, 6" converted to: [1, 2, 3, 4, 5, 6, 8, 9, 10]
String "11, 11, 12, 12, 1-5, 3-7" converted to: [1, 2, 3, 4, 5, 6, 7, 11, 12]
"""
fullDiapason = []
try:
for element in diapason.split(','):
fullDiapason += [x for x in range(int(element.split('-')[0]), int(element.split('-')[-1]) + 1)]
except Exception:
FCLogger.error('"{}" is not correct diapason string!'.format(diapason))
return []
return sorted(list(set(fullDiapason)))
def Trapezium(self, x):
"""
This is trapezium membership function with real inputs x and parameters a, b, c, d.
"""
a, b, c, d, result = 0, 0, 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
c = self._parameters['c']
d = self._parameters['d']
if x < a:
result = 0
elif (a < x) and (x < c):
result = (x - a) / (c - a)
elif (c <= x) and (x <= d):
result = 1
elif (d < x) and (x <= b):
result = (b - x) / (b - d)
else:
result = 0
except Exception:
FCLogger.error(traceback.format_exc())
FCLogger.error('Trapezium membership function use real inputs x and parameters a, b, c, d.')
FCLogger.error('Your inputs: mju_trapezium({}, {}, {}, {}, {})'.format(x, a, b, c, d))
return 0
return result
def Triangle(self, x):
"""
This is triangle membership function with real inputs x and parameters a, b, c.
"""
a, b, c, result = 0, 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
c = self._parameters['c']
if x <= a:
result = 0
elif (a < x) and (x <= c):
result = (x - a) / (c - a)
elif (c < x) and (x < b):
result = (b - x) / (b - c)
else:
result = 0
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error(
'Triangle membership function use real inputs x and parameters a, b, c.'
)
FCLogger.error('Your inputs: mju_triangle({}, {}, {}, {})'.format(
x, a, b, c))
finally:
return result
def _DefuzRawData(self):
"""
Functions parse raw text data and converting fuzzy values to its real represents.
"""
defuzData = []
try:
for line in self.rawData:
# defuzzificating fuzzy values to real values:
defuzzyValues = []
for itemValue in line:
num = 0
try:
num = float(itemValue)
except:
level = self.scale.GetLevelByName(levelName=itemValue, exactMatching=False)
if level:
if isinstance(level['fSet'], FuzzySet):
num = level['fSet'].Defuz()
else:
FCLogger.warning('{} not correct real or fuzzy value! It is reset at 0.'.format(itemValue))
defuzzyValues.append(num)
defuzData.append(defuzzyValues)
except:
defuzData = []
FCLogger.error(traceback.format_exc())
FCLogger.error('An error occurred while defuzzyficating values in raw data!')
finally:
self._rawDefuzData = defuzData
def Triangle(self, x):
"""
This is triangle membership function with real inputs x and parameters a, b, c.
"""
a, b, c, result = 0, 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
c = self._parameters['c']
if x <= a:
result = 0
elif (a < x) and (x <= c):
result = (x - a) / (c - a)
elif (c < x) and (x < b):
result = (b - x) / (b - c)
else:
result = 0
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error('Triangle membership function use real inputs x and parameters a, b, c.')
FCLogger.error('Your inputs: mju_triangle({}, {}, {}, {})'.format(x, a, b, c))
finally:
return result
def Parabolic(self, x):
"""
This is parabolic membership function with real inputs x and parameters a, b.
"""
a, b, result = 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
if x <= a:
result = 0
elif (a < x) and (x <= (a + b) / 2):
result = (2 * (x - a) ** 2) / (b - a) ** 2
elif ((a + b) / 2 < x) and (x < b):
result = 1 - (2 * (x - b) ** 2) / (b - a) ** 2
else:
result = 1
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error('Parabolic membership function use real inputs x and parameters a, b.')
FCLogger.error('Your inputs: mju_parabolic({}, {}, {})'.format(x, a, b))
finally:
return result
def ClassificationResults(self, fullEval=False, needFuzzy=False):
"""
Method use for receiving results after activating Neuronet with all input vectors.
If fullEval = True then method calculate results for all input vectors, otherwise for first and last two input vectors.
if needFuzzy = True then appropriate output values converting into fuzzy values after activating, otherwise used real values.
"""
classificationResults = []
FCLogger.debug('Classification results: ')
if fullEval:
if needFuzzy:
for vector in self._rawData:
inputVector = vector[:self.config[0]]
expectedVector = vector[self.config[-1] + 1:]
classificationResults.append(self.ClassificationResultForOneVector(inputVector, expectedVector, needFuzzy))
else:
for vector in self._rawDefuzData:
inputVector = vector[:self.config[0]]
expectedVector = vector[self.config[-1] + 1:]
classificationResults.append(self.ClassificationResultForOneVector(inputVector, expectedVector))
else:
classificationResults.append(
self.ClassificationResultForOneVector(self._rawData[0][:self.config[0]] if not needFuzzy else self._rawDefuzData[0][:self.config[0]],
self._rawData[0][self.config[-1] + 1:] if not needFuzzy else self._rawDefuzData[0][self.config[-1] + 1:], needFuzzy))
classificationResults.append(
self.ClassificationResultForOneVector(self._rawData[1][:self.config[0]] if not needFuzzy else self._rawDefuzData[1][:self.config[0]],
self._rawData[1][self.config[-1] + 1:] if not needFuzzy else self._rawDefuzData[1][self.config[-1] + 1:], needFuzzy))
FCLogger.debug(' ... skipped ...')
classificationResults.append(
self.ClassificationResultForOneVector(self._rawData[-2][:self.config[0]] if not needFuzzy else self._rawDefuzData[-2][:self.config[0]],
self._rawData[-2][self.config[-1] + 1:] if not needFuzzy else self._rawDefuzData[-2][self.config[-1] + 1:], needFuzzy))
classificationResults.append(
self.ClassificationResultForOneVector(self._rawData[-1][:self.config[0]] if not needFuzzy else self._rawDefuzData[-1][:self.config[0]],
self._rawData[-1][self.config[-1] + 1:] if not needFuzzy else self._rawDefuzData[-1][self.config[-1] + 1:], needFuzzy))
return classificationResults
def Hyperbolic(self, x):
"""
This is hyperbolic membership function with real inputs x and parameters a, b, c.
"""
a, b, c, result = 0, 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
c = self._parameters['c']
if x <= c:
result = 1
else:
result = 1 / (1 + (a * (x - c))**b)
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error(
'Hyperbolic membership function use real inputs x and parameters a, b, c.'
)
FCLogger.error(
'Your inputs: mju_hyperbolic({}, {}, {}, {})'.format(
x, a, b, c))
finally:
return result
def Parabolic(self, x):
"""
This is parabolic membership function with real inputs x and parameters a, b.
"""
a, b, result = 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
if x <= a:
result = 0
elif (a < x) and (x <= (a + b) / 2):
result = (2 * (x - a)**2) / (b - a)**2
elif ((a + b) / 2 < x) and (x < b):
result = 1 - (2 * (x - b)**2) / (b - a)**2
else:
result = 1
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error(
'Parabolic membership function use real inputs x and parameters a, b.'
)
FCLogger.error('Your inputs: mju_parabolic({}, {}, {})'.format(
x, a, b))
finally:
return result
def Trapezium(self, x):
"""
This is trapezium membership function with real inputs x and parameters a, b, c, d.
"""
a, b, c, d, result = 0, 0, 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
c = self._parameters['c']
d = self._parameters['d']
if x < a:
result = 0
elif (a < x) and (x < c):
result = (x - a) / (c - a)
elif (c <= x) and (x <= d):
result = 1
elif (d < x) and (x <= b):
result = (b - x) / (b - d)
else:
result = 0
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error('Trapezium membership function use real inputs x and parameters a, b, c, d.')
FCLogger.error('Your inputs: mju_trapezium({}, {}, {}, {}, {})'.format(x, a, b, c, d))
finally:
return result
def separator(self, value):
if isinstance(value, str):
if value.upper() == 'TAB':
self._separator = '\t'
elif value.upper() == 'SPACE':
self._separator = ' '
else:
if len(value) == 1:
self._separator = value
else:
FCLogger.warning(
'Parameter separator must be an 1-character string! It was set to TAB char, by default.'
)
self._separator = '\t'
else:
self._separator = '\t'
FCLogger.warning(
'Parameter separator must be an 1-character string! It was set to TAB char, by default.'
)
def DefuzRawData(self):
"""
Functions parse raw text data and converting fuzzy values to its real represents.
"""
FCLogger.info('Defuzzyficating raw data ...')
defuzData = []
try:
for line in self.rawData:
defuzValues = []
for itemValue in line:
num = 0
try:
num = float(itemValue)
except Exception:
level = self.scale.GetLevelByName(
levelName=itemValue.capitalize())
if level:
num = level['fSet'].Defuz()
else:
FCLogger.warning(
itemValue +
' - is not correct real or fuzzy value! It is reset at 0.'
)
defuzValues.append(num)
defuzData.append(defuzValues)
except Exception:
defuzData = []
FCLogger.error(traceback.format_exc())
FCLogger.error(
'An error occurred while defuzzyficating values in raw data!')
finally:
self._rawDefuzData = defuzData
def Desirability(self, y):
"""
This is Harrington's desirability membership function with real input y without any parameters.
"""
try:
result = math.exp(-math.exp(-y))
except Exception:
FCLogger.error(traceback.format_exc())
FCLogger.error("Harrington's desirability membership function use only real input y without any parameters.")
FCLogger.error('Your inputs: mju_desirability({})'.format(y))
return 0
return result
def LoadNetwork(self):
"""
Loading network dump from file.
"""
FCLogger.debug('Loading network from PyBrain xml-formatted file...')
net = None
if os.path.exists(self.networkFile):
net = NetworkReader.readFrom(self.networkFile)
FCLogger.info('Network loaded from dump-file: {}'.format(os.path.abspath(self.networkFile)))
else:
FCLogger.warning('{} - file with Neural Network configuration not exist!'.format(os.path.abspath(self.networkFile)))
self.network = net
def Desirability(self, y):
"""
This is Harrington's desirability membership function with real input y without any parameters.
"""
result = 0
try:
result = math.exp(-math.exp(-y))
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error("Harrington's desirability membership function use only real input y without any parameters.")
FCLogger.error('Your inputs: mju_desirability({})'.format(y))
finally:
return result
def learningRate(self, value):
if isinstance(value, float):
if (value > 0) and (value <= 1):
self._learningRate = value
elif value <= 0:
self._learningRate = 0.05
FCLogger.warning('Parameter rate might be greater than 0! It was set to 0.05 now.')
else:
self._learningRate = 1
FCLogger.warning('Parameter rate might be less than 1! It was set to 1 now.')
else:
self._epochs = 0.05
FCLogger.warning('Parameter rate might be a float number! It was set to 0.05, by default.')
def momentum(self, value):
if isinstance(value, float):
if (value > 0) and (value <= 1):
self._momentum = value
elif value <= 0:
self._momentum = 0.01
FCLogger.warning('Parameter momentum might be greater than 0! It was set to 0.01 now.')
else:
self._momentum = 1
FCLogger.warning('Parameter momentum might be less than 1! It was set to 1 now.')
else:
self._momentum = 0.01
FCLogger.warning('Parameter momentum might be a float number! It was set to 0.01, by default.')
def CreateReport(self, results=None, fuzzyOutput=True):
"""
Creating text report after classificate vector-candidates.
results is a list of tuples in ClassificationResults() format.
fuzzyOutput is a key for show fuzzy values if True.
"""
noReportCreationErrors = True # successful of Creating Report process flag
FCLogger.debug('Creating Classificate Report File...')
try:
if not results:
results = self.ClassificationResults(fullEval=True, needFuzzy=fuzzyOutput)
with open(self.reportFile, 'w') as fH:
fH.write('Neuronet: {}\n\n'.format(os.path.abspath(self.networkFile)))
fH.write('{}\n\n'.format(self.scale))
fH.write('Classification results for candidates vectors:\n\n')
for result in results:
if fuzzyOutput:
fH.write(' Input: {}\tOutput: {}{}\n'.format(
result[0], result[1], '\tExpected: {}'.format(result[2]) if result[2] else ''))
else:
fH.write(' Input: {}\tOutput: {}{}\n'.format(
result[0], result[1], '\tExpected: {}\tError: {}'.format(result[2], result[3]) if result[2] else ''))
FCLogger.info('Classificate Report File created: {}'.format(os.path.abspath(self.reportFile)))
except:
noReportCreationErrors = False
FCLogger.error(traceback.format_exc())
FCLogger.error('An error occurred while Classificate Report creating!')
finally:
return noReportCreationErrors
def Sigmoidal(self, x):
"""
This is sigmoidal membership function with real inputs x and parameters a, b.
"""
a, b, result = 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
result = 1 / (1 + math.exp(1) ** (-a * (x - b)))
except Exception:
FCLogger.error(traceback.format_exc())
FCLogger.error('Sigmoidal membership function use real inputs x and parameters a, b.')
FCLogger.error('Your inputs: mju_sigmoidal({}, {}, {})'.format(x, a, b))
return 0
return result
def LoadNetwork(self):
"""
Loading network dump from file.
"""
FCLogger.debug('Loading network from PyBrain xml-formatted file...')
net = None
if os.path.exists(self.networkFile):
net = NetworkReader.readFrom(self.networkFile)
FCLogger.info('Network loaded from dump-file: {}'.format(
os.path.abspath(self.networkFile)))
else:
FCLogger.warning(
'{} - file with Neural Network configuration not exist!'.
format(os.path.abspath(self.networkFile)))
self.network = net
def Sigmoidal(self, x):
"""
This is sigmoidal membership function with real inputs x and parameters a, b.
"""
a, b, result = 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
result = 1 / (1 + math.exp(1) ** (-a * (x - b)))
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error('Sigmoidal membership function use real inputs x and parameters a, b.')
FCLogger.error('Your inputs: mju_sigmoidal({}, {}, {})'.format(x, a, b))
finally:
return result
def Exponential(self, x):
"""
This is exponential membership function with real inputs x and parameters a, b.
"""
a, b, result = 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
if b != 0:
result = math.exp(1) ** (-0.5 * ((x - a) / b) ** 2)
except Exception:
FCLogger.error(traceback.format_exc())
FCLogger.error('Exponential membership function use real inputs x and parameters a, b.')
FCLogger.error('Your inputs: mju_exponential({}, {}, {})'.format(x, a, b))
return 0
return result
def Exponential(self, x):
"""
This is exponential membership function with real inputs x and parameters a, b.
"""
a, b, result = 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
if b != 0:
result = math.exp(1) ** (-0.5 * ((x - a) / b) ** 2)
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error('Exponential membership function use real inputs x and parameters a, b.')
FCLogger.error('Your inputs: mju_exponential({}, {}, {})'.format(x, a, b))
finally:
return result
def Bell(self, x):
"""
This is bell membership function with real inputs x and parameters a, b, c.
"""
a, b, c, result = 0, 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
c = self._parameters['c']
if x < b:
result = self.Parabolic(x)
elif (b <= x) and (x <= c):
result = 1
else:
aOld = self._parameters['a']
bOld = self._parameters['b']
self._parameters['a'] = c
self._parameters['b'] = c + b - a
result = 1 - self.Parabolic(x)
self._parameters['a'] = aOld
self._parameters['b'] = bOld
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error(
'Bell membership function use real inputs x and parameters a, b, c.'
)
FCLogger.error('Your inputs: mju_bell({}, {}, {}, {})'.format(
x, a, b, c))
finally:
return result
def _DefuzRawData(self):
"""
Functions parse raw text data and converting fuzzy values to its real represents.
"""
defuzData = []
try:
for line in self.rawData:
# defuzzificating fuzzy values to real values:
defuzzyValues = []
for itemValue in line:
num = 0
try:
num = float(itemValue)
except:
level = self.scale.GetLevelByName(levelName=itemValue,
exactMatching=False)
if level:
if isinstance(level['fSet'], FuzzySet):
num = level['fSet'].Defuz()
else:
FCLogger.warning(
'{} not correct real or fuzzy value! It is reset at 0.'
.format(itemValue))
defuzzyValues.append(num)
defuzData.append(defuzzyValues)
except:
defuzData = []
FCLogger.error(traceback.format_exc())
FCLogger.error(
'An error occurred while defuzzyficating values in raw data!')
finally:
self._rawDefuzData = defuzData
def learningRate(self, value):
if isinstance(value, float):
if (value > 0) and (value <= 1):
self._learningRate = value
elif value <= 0:
self._learningRate = 0.05
FCLogger.warning(
'Parameter rate might be greater than 0! It was set to 0.05 now.'
)
else:
self._learningRate = 1
FCLogger.warning(
'Parameter rate might be less or equal 1! It was set to 1 now.'
)
else:
self._learningRate = 0.05
FCLogger.warning(
'Parameter rate might be a float number! It was set to 0.05, by default.'
)
def momentum(self, value):
if isinstance(value, float):
if (value > 0) and (value <= 1):
self._momentum = value
elif value <= 0:
self._momentum = 0.01
FCLogger.warning(
'Parameter momentum might be greater than 0! It was set to 0.01 now.'
)
else:
self._momentum = 1
FCLogger.warning(
'Parameter momentum might be less or equal 1! It was set to 1 now.'
)
else:
self._momentum = 0.01
FCLogger.warning(
'Parameter momentum might be a float number! It was set to 0.01, by default.'
)
def epsilon(self, value):
if isinstance(value, float):
if (value > 0) and (value <= 1):
self._epsilon = value
elif value <= 0:
self._epsilon = 0.01
FCLogger.warning(
'Parameter epsilon might be greater than 0! It was set to 0.01 now.'
)
else:
self._epsilon = 1
FCLogger.warning(
'Parameter epsilon might be less or equal 1! It was set to 1 now.'
)
else:
self._epsilon = 0.05
FCLogger.warning(
'Parameter epsilon might be a float number! It was set to 0.05, by default.'
)
def Bell(self, x):
"""
This is bell membership function with real inputs x and parameters a, b, c.
"""
a, b, c, result = 0, 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
c = self._parameters['c']
if x < b:
result = self.Parabolic(x)
elif (b <= x) and (x <= c):
result = 1
else:
aOld = self._parameters['a']
bOld = self._parameters['b']
self._parameters['a'] = c
self._parameters['b'] = c + b - a
result = 1 - self.Parabolic(x)
self._parameters['a'] = aOld
self._parameters['b'] = bOld
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error('Bell membership function use real inputs x and parameters a, b, c.')
FCLogger.error('Your inputs: mju_bell({}, {}, {}, {})'.format(x, a, b, c))
finally:
return result
def Hyperbolic(self, x):
"""
This is hyperbolic membership function with real inputs x and parameters a, b, c.
"""
a, b, c, result = 0, 0, 0, 0
try:
a = self._parameters['a']
b = self._parameters['b']
c = self._parameters['c']
if x <= c:
result = 1
else:
result = 1 / (1 + (a * (x - c)) ** b)
except:
result = 0
FCLogger.error(traceback.format_exc())
FCLogger.error('Hyperbolic membership function use real inputs x and parameters a, b, c.')
FCLogger.error('Your inputs: mju_hyperbolic({}, {}, {}, {})'.format(x, a, b, c))
finally:
return result
def PrepareDataSet(self):
"""
This method preparing PyBrain dataset from raw data file.
"""
learnData = None
FCLogger.info('Converting parsed raw-data into PyBrain dataset format...')
try:
if self.config:
if len(self.config) > 2:
learnData = SupervisedDataSet(self.config[0], self.config[-1]) # first and last values in config tuple
else:
raise Exception('Network config must contains more than 2 parameters!')
else:
raise Exception('Network config not defined!')
# add samples from defuz raw-data as [[input_vector], [output_vector]] for PyBrain network:
for sample in self._rawDefuzData:
learnData.addSample(sample[:self.config[0]], sample[self.config[0]:self.config[0] + self.config[-1]])
FCLogger.debug('PyBrain dataset vectors - target (output) and input:')
for line in str(learnData).split('\n'):
if line:
FCLogger.debug(' {}'.format(line))
FCLogger.info('PyBrain dataset successfully prepared.')
except:
learnData = None
FCLogger.error(traceback.format_exc())
FCLogger.error('An error occurred while preparing PyBrain dataset!')
finally:
self.dataSet = learnData
def Train(self):
"""
Realize training mechanism.
"""
noTrainErrors = True # successful train flag
try:
if self.trainer:
started = datetime.now()
FCLogger.debug('Max epochs: {}'.format(self._epochs))
for x in range(self._epochs):
FCLogger.debug('Epoch: {}'.format(self.trainer.epoch + 1))
self.trainer.train() # training network
self.ClassificationResults(fullEval=False, needFuzzy=False) # show some results for ethalon vectors
if x % 10 == 0:
FCLogger.debug('Auto saving Neuronet configuration...')
self.SaveNetwork()
if self._epochs > 1:
self.SaveNetwork()
FCLogger.debug('Duration of learning: {}'.format(datetime.now() - started))
else:
raise Exception('Trainer instance not created!')
except:
noTrainErrors = False
FCLogger.error(traceback.format_exc())
FCLogger.error('An error occurred while Training Fuzzy Network!')
finally:
return noTrainErrors
def CreateTrainer(self):
"""
This method preparing PyBrain trainer.
"""
backpropTrainer = None
FCLogger.info('Initializing PyBrain backpropagating trainer...')
try:
if self.network:
if self.dataSet:
FCLogger.debug('Trainer using parameters:')
FCLogger.debug(' - PyBrain network previously created,')
FCLogger.debug(' - PyBrain dataset previously created,')
FCLogger.debug(' - epoch parameter: {}'.format(self._epochs))
FCLogger.debug(' - network learning rate parameter: {}'.format(self._learningRate))
FCLogger.debug(' - momentum parameter: {}'.format(self._momentum))
backpropTrainer = BackpropTrainer(self.network, self.dataSet, learningrate=self._learningRate, momentum=self._momentum)
else:
raise Exception('PyBrain dataset not exist!')
else:
raise Exception('PyBrain network not exist!')
FCLogger.info('PyBrain network successfully created.')
except:
backpropTrainer = None
FCLogger.error(traceback.format_exc())
FCLogger.error('An error occurred while creating PyBrain trainer!')
finally:
self.trainer = backpropTrainer
def CreateNetwork(self):
"""
This method creating instance of PyBrain network.
"""
net = None
FCLogger.info('Creating PyBrain network...')
try:
if self.config:
if len(self.config) > 2:
hLayers = self.config[1:-1] # parameters for hidden layers
FCLogger.debug('Neuronet configuration: Config = <inputs, {layers}, outputs>')
FCLogger.debug(' - inputs is dimension of all input vectors: {},'.format(self.config[0]))
FCLogger.debug(' - outputs is dimension of all output vectors: {},'.format(self.config[-1]))
FCLogger.debug(' - count of hidden layers for Neuronet: {},'.format(len(hLayers)))
if len(hLayers) <= 10:
for nNum, dim in enumerate(hLayers):
FCLogger.debug(' ... dimension of {} hidden layer: {}'.format(nNum, dim))
else:
FCLogger.debug(' ... dimension of 0 hidden layer: {}'.format(hLayers[0]))
FCLogger.debug(' ... dimension of 1 hidden layer: {}'.format(hLayers[1]))
FCLogger.debug(' ... skipped ...')
FCLogger.debug(' ... dimension of {} hidden layer: {}'.format(len(hLayers) - 2, hLayers[-2]))
FCLogger.debug(' ... dimension of {} hidden layer: {}'.format(len(hLayers) - 1, hLayers[-1]))
net = buildNetwork(*self.config) # create network with config
else:
raise Exception('Network config must contains at least 3 parameters: (inputs_count, layer1_count, outputs_count)!')
else:
raise Exception('Network config not defined!')
FCLogger.info('PyBrain network successfully created.')
except:
net = None
FCLogger.error(traceback.format_exc())
FCLogger.error('An error occurred while preparing PyBrain network!')
finally:
self.network = net
def ParseRawDataFile(self):
"""
Get list of lines with raw string data without first header-line and empty lines.
"""
raw = []
FCLogger.info('Parsing file with raw data...')
try:
if self.rawDataFile:
with open(self.rawDataFile, newline='') as csvfile:
FCLogger.debug('Opened file: {}'.format(self.rawDataFile))
for row in csv.reader(csvfile, delimiter='\t'):
if row:
raw.append(row)
if raw:
raw = raw[1:] # use data without first header-line
FCLogger.debug('Parsed raw-data vectors:')
if len(raw) <= 5:
for line in raw:
FCLogger.debug(' {}'.format(line))
else:
FCLogger.debug(' {}'.format(raw[0]))
FCLogger.debug(' {}'.format(raw[1]))
FCLogger.debug(' [ ... skipped ... ]')
FCLogger.debug(' {}'.format(raw[-2]))
FCLogger.debug(' {}'.format(raw[-1]))
FCLogger.info('File with raw data successfully parsed.')
except:
raw = []
FCLogger.error(traceback.format_exc())
FCLogger.error('An error occurred while parsing raw data file!')
finally:
self.rawData = raw # list of input vectors without first header line
def ClassificationResults(self,
fullEval=False,
needFuzzy=False,
showExpectedVector=True,
printLog=True):
"""
Method use for receiving results after activating Neuronet with all input vectors.
fullEval is options to calculate results for all input vectors if True or not. False by default. Affects to speed.
If needFuzzy = True then appropriate output values converting into fuzzy values after activating, otherwise used real values.
If showExpectedVector = True then vector with expected results will shown in log and result file.
If printLog = False then results not printing to log.
"""
classificationResults = []
inputHeaders = self.headers[:self.config[0]]
outputHeaders = self.headers[len(self.headers) - self.config[-1]:]
if printLog:
FCLogger.debug('Classification results:')
if len(inputHeaders) <= 10:
shortHeaderStr = ' Header: [' + ' '.join(
head for head in inputHeaders) + ']\t[' + ' '.join(
head for head in outputHeaders) + ']'
FCLogger.debug(shortHeaderStr)
else:
longHeaderStr = ' Header: [' + inputHeaders[
0] + ' ' + inputHeaders[1] + ' ... ' + inputHeaders[
-2] + ' ' + inputHeaders[-1] + ']\t[' + ' '.join(
head for head in outputHeaders) + ']'
FCLogger.debug(longHeaderStr)
if fullEval:
if needFuzzy:
for vecNum, vector in enumerate(self._rawData):
inputVector = vector[:self.config[0]]
expectedVector = vector[
len(vector) -
self.config[-1]:] if showExpectedVector else None
classificationResults.append(
self.ClassificationResultForOneVector(
inputVector, expectedVector, needFuzzy, printLog))
else:
for vecNum, vector in enumerate(self._rawDefuzData):
inputVector = vector[:self.config[0]]
expectedVector = vector[
len(vector) -
self.config[-1]:] if showExpectedVector else None
classificationResults.append(
self.ClassificationResultForOneVector(
inputVector, expectedVector, printLog=printLog))
else:
if len(self._rawData) <= 10:
for vecNum, rawLine in enumerate(self._rawData):
classificationResults.append(
self.ClassificationResultForOneVector(
rawLine[:self.config[0]] if not needFuzzy else
self._rawDefuzData[vecNum][:self.config[0]],
rawLine[len(rawLine) - self.config[-1]:]
if not needFuzzy else self._rawDefuzData[vecNum]
[len(self._rawDefuzData[vecNum]) -
self.config[-1]:],
needFuzzy,
printLog=printLog))
else:
classificationResults.append(
self.ClassificationResultForOneVector(
self._rawData[0][:self.config[0]] if not needFuzzy else
self._rawDefuzData[0][:self.config[0]],
self._rawData[0][len(self._rawData[0]) -
self.config[-1]:] if not needFuzzy
else self._rawDefuzData[0][len(self._rawDefuzData[0]) -
self.config[-1]:],
needFuzzy,
printLog=printLog))
classificationResults.append(
self.ClassificationResultForOneVector(
self._rawData[1][:self.config[0]] if not needFuzzy else
self._rawDefuzData[1][:self.config[0]],
self._rawData[1][len(self._rawData[1]) -
self.config[-1]:] if not needFuzzy
else self._rawDefuzData[1][len(self._rawDefuzData[1]) -
self.config[-1]:],
needFuzzy,
printLog=printLog))
if printLog:
FCLogger.debug(' ... skipped ...')
classificationResults.append(
self.ClassificationResultForOneVector(
self._rawData[-2][:self.config[0]] if not needFuzzy
else self._rawDefuzData[-2][:self.config[0]],
self._rawData[-2][len(self._rawData[-2]) -
self.config[-1]:]
if not needFuzzy else
self._rawDefuzData[-2][len(self._rawDefuzData[-2]) -
self.config[-1]:],
needFuzzy,
printLog=printLog))
classificationResults.append(
self.ClassificationResultForOneVector(
self._rawData[-1][:self.config[0]] if not needFuzzy
else self._rawDefuzData[-1][:self.config[0]],
self._rawData[-1][len(self._rawData[-1]) -
self.config[-1]:]
if not needFuzzy else
self._rawDefuzData[-1][len(self._rawDefuzData[-1]) -
self.config[-1]:],
needFuzzy,
printLog=printLog))
return classificationResults
def Train(self):
"""
Realize training mechanism.
"""
try:
if self._epochs > 0:
if self.trainer:
started = datetime.now()
FCLogger.info('Max epochs: ' + str(self._epochs))
if os.path.exists(self.bestNetworkFile):
os.remove(self.bestNetworkFile
) # remove old best network before training
if os.path.exists(self.bestNetworkInfoFile):
os.remove(
self.bestNetworkInfoFile
) # remove best network info file before training
for epoch in range(self._epochs):
# --- Updating current progress:
self.progress = (epoch + 1) * 100 / self._epochs
if (0 < epoch < self._epochs -
1) and (epoch + 1) % self._epochsToUpdate == 0:
totTimeSeconds = (datetime.now() -
started).total_seconds()
timeRemainingSeconds = round(totTimeSeconds /
self.progress * 100 -
totTimeSeconds)
timeInfo = ', total time: {}, time remaining: {}'.format(
timedelta(seconds=round(totTimeSeconds)),
timedelta(seconds=timeRemainingSeconds))
else:
timeInfo = ''
FCLogger.info(
'Progress: {:.2f}% (epoch: {} in {}{})'.format(
self.progress, self.trainer.epoch + 1,
self._epochs, timeInfo))
if (epoch + 1) % self._epochsToUpdate == 0:
# Current results is the list of result vectors: [[defuzInput, outputVector, defuzExpectedVector, errorVector], ...]:
currentResult = self.ClassificationResults(
fullEval=True,
needFuzzy=False,
showExpectedVector=True,
printLog=False)
# Counting error as length of list with only vectors with euclidian norm between expected vector and current vector given error > self._epsilon:
vectorsWithErrors = [
vecError[3] for vecError in currentResult
if math.sqrt(sum([x * x for x in vecError[3]]))
> self._epsilon
]
self.currentFalsePercent = len(
vectorsWithErrors) * 100 / len(currentResult)
errorString = '{:.1f}% ({} of {})'.format(
self.currentFalsePercent,
len(vectorsWithErrors), len(currentResult))
FCLogger.info(
' - false classificated of vectors: ' +
errorString)
if epoch == 0:
self.bestNetworkFalsePercent = self.currentFalsePercent # best percent after first epoch
# --- Saving current best network:
if self.currentFalsePercent < self.bestNetworkFalsePercent:
if os.path.exists(self.networkFile):
self.bestNetworkFalsePercent = self.currentFalsePercent
FCLogger.info('Best network found:')
FCLogger.info(' Config: ' +
str(self.config))
FCLogger.info(' Epoch: ' + str(epoch + 1))
FCLogger.info(
' Number of error vectors (Euclidian norm > epsilon): '
+ errorString)
with open(self.bestNetworkInfoFile, 'w') as fH:
fH.write('Best network common results:\n')
fH.write(' Config: ' +
str(self.config) + '\n')
fH.write(' Epoch: ' + str(epoch + 1) +
'\n')
fH.write(
' Number of error vectors (Euclidian norm > epsilon): '
+ errorString + '\n\n')
fH.write(
'All of learning parameters of FuzzyNeuroNetwork object:\n'
+ '-' * 80 + '\n')
for param in sorted(self.__dict__):
fH.write(' ' + param + ' = ' +
str(self.__dict__[param]) +
'\n\n')
shutil.copyfile(self.networkFile,
self.bestNetworkFile)
FCLogger.info(
'Best network saved to file: ' +
os.path.abspath(self.bestNetworkFile))
FCLogger.info(
'Common information about best network saved to file: '
+
os.path.abspath(self.bestNetworkInfoFile))
# --- Stop train if the best network found:
if self.currentFalsePercent <= self._stop:
FCLogger.info(
'Current percent of false classificated vectors is {:.1f}% less than stop value {:.1f}%.'
.format(self.currentFalsePercent, self._stop))
break
self.trainer.train() # training network
if epoch % 10 == 0:
self.SaveNetwork() # dump network every 10th time
if self._epochs > 1:
self.SaveNetwork(
) # save network at the end of learning
# --- Replace last network with the best network:
if os.path.exists(self.networkFile) and os.path.exists(
self.bestNetworkFile):
os.remove(self.networkFile)
shutil.copyfile(self.bestNetworkFile, self.networkFile)
FCLogger.info(
'Current network replace with the best network.')
durationSeconds = round(
(datetime.now() - started).total_seconds())
FCLogger.info('Duration of learning: {}'.format(
timedelta(seconds=durationSeconds)))
else:
raise Exception('Trainer instance not created!')
else:
FCLogger.warning(
'Epoch of learning count is 0. Train not run!')
except Exception:
FCLogger.error(traceback.format_exc())
FCLogger.error('An error occurred while Training Fuzzy Network!')
return False
return True
