def fitness(inputIDs):
inputIDs = [int(round(x,0)) for x in inputIDs]
print "Inputs:", inputIDs,
if not 1 in inputIDs: return 9999.0
inMFs = {}
inPARAMs = {}
for i in range(len(input_list)):
if inputIDs[i] == 1:
inMFs[input_list[i]] = inputMFs[input_list[i]]
inPARAMs[input_list[i]] = inputPARAMs[input_list[i]]
dataVal = copy.deepcopy(combDataVal)
dataTrain = copy.deepcopy(combDataTrain)
rule_grid = train_system(inMFs, outputMFs, dataTrain, inDataMFs=inDataForm, outDataMFs=outDataForm)
write_fcl_file_FRBS(inPARAMs, outputPARAMs, rule_grid, None, 'opt_sys_phi.fcl') #write out FCL
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, defuzz = build_fuzz_system('opt_sys_phi.fcl') #get system
sys = Fuzzy_System(inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, defuzz)
#sys.run(None, TESTMODE=True)
error = getError(dataVal, sys, inMF=inDataForm, outMF=outDataForm, sysOutType=errType) #test system
base_mse = (1.0/len(error))*sum([err[2]**2 for err in error if err <> None])
print 'MSE:', base_mse
return base_mse
def fitness(varList, penalty=True): #, tBESTfit=tempBESTfit):
defuzz = None
#try:
with Timer() as t:
#translate varlist to MFs (MFs in list form)
inMFs, outMFs = deparameterize(list(MFstructIn), list(MFstructOut),
list(varList))
#translate list MFs into MF functions (MF in array form)
inMF_funcs, outMF_funcs = read_data.generate_MFs(inMFs, outMFs)
#train system
rule_grid = train_numerical.train_system(inMF_funcs,
outMF_funcs,
train_data,
inDataMFs=inMFform,
outDataMFs=outMFform,
maxDataN=trainMax)
#write out FCL
train_numerical.write_fcl_file_FRBS(inMFs, outMFs, rule_grid,
defuzz, fclName)
#build test system
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, \
implication, defuzz = build_fuzz_system(fclName)
testSys = Fuzzy_System(inputs, outputs, rulebase, AND_operator, \
OR_operator, aggregator, implication, defuzz)
#test system
error = getError(copy.deepcopy(val_data),
testSys,
inMF=inMFform,
outMF=outMFform,
sysOutType=errorType,
errType='dist')
MSE = (1.0 / len([err for err in error if err[2] <> None])) * sum(
[err[2]**2 for err in error if err[2] <> None])
if penalty:
k = float(len([e for e in error if e[2] == None])) / len(error)
MSE = MSE * math.exp(
2.0 * k) #penalty for lots of "Nones" from error function
else:
k = 0
print " ==> system fitness %.4f in %.1f sec (k=%.2f)" % (MSE, t.secs,
k)
if MSE < tempBESTfit[0]:
train_numerical.write_fcl_file_FRBS(
inMFs, outMFs, rule_grid, defuzz,
fclName[:-4] + '_tempBEST_' + str(MSE) + '.fcl')
tempBESTfit[0] = MSE
print "--- new temp best written ---"
return MSE
def fitness(varList, penalty=True):#, tBESTfit=tempBESTfit):
defuzz = None
#try:
with Timer() as t:
#translate varlist to MFs (MFs in list form)
inMFs, outMFs = deparameterize(list(MFstructIn), list(MFstructOut), list(varList))
#translate list MFs into MF functions (MF in array form)
inMF_funcs, outMF_funcs = read_data.generate_MFs(inMFs, outMFs)
#train system
rule_grid = train_numerical.train_system(inMF_funcs, outMF_funcs, train_data,
inDataMFs=inMFform, outDataMFs=outMFform,
maxDataN=trainMax)
#write out FCL
train_numerical.write_fcl_file_FRBS(inMFs, outMFs, rule_grid, defuzz, fclName)
#build test system
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, \
implication, defuzz = build_fuzz_system(fclName)
testSys = Fuzzy_System(inputs, outputs, rulebase, AND_operator, \
OR_operator, aggregator, implication, defuzz)
#test system
error = getError(copy.deepcopy(val_data), testSys, inMF=inMFform,
outMF=outMFform, sysOutType=errorType, errType='dist')
MSE = (1.0/len([err for err in error if err[2] <> None]))*sum([err[2]**2 for err in error if err[2] <> None])
if penalty:
k = float(len([e for e in error if e[2] == None]))/len(error)
MSE = MSE*math.exp(2.0*k) #penalty for lots of "Nones" from error function
else: k = 0
print " ==> system fitness %.4f in %.1f sec (k=%.2f)" % (MSE, t.secs,k)
if MSE < tempBESTfit[0]:
train_numerical.write_fcl_file_FRBS(inMFs, outMFs, rule_grid, defuzz, fclName[:-4]+'_tempBEST_'+str(MSE)+'.fcl')
tempBESTfit[0] = MSE
print "--- new temp best written ---"
return MSE
def fitness(inputIDs):
inputIDs = [int(round(x, 0)) for x in inputIDs]
print "Inputs:", inputIDs,
if not 1 in inputIDs: return 9999.0
inMFs = {}
inPARAMs = {}
for i in range(len(input_list)):
if inputIDs[i] == 1:
inMFs[input_list[i]] = inputMFs[input_list[i]]
inPARAMs[input_list[i]] = inputPARAMs[input_list[i]]
dataVal = copy.deepcopy(combDataVal)
dataTrain = copy.deepcopy(combDataTrain)
rule_grid = train_system(inMFs,
outputMFs,
dataTrain,
inDataMFs=inDataForm,
outDataMFs=outDataForm)
write_fcl_file_FRBS(inPARAMs, outputPARAMs, rule_grid, None,
'opt_sys_phi.fcl') #write out FCL
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, defuzz = build_fuzz_system(
'opt_sys_phi.fcl') #get system
sys = Fuzzy_System(inputs, outputs, rulebase, AND_operator,
OR_operator, aggregator, implication, defuzz)
#sys.run(None, TESTMODE=True)
error = getError(dataVal,
sys,
inMF=inDataForm,
outMF=outDataForm,
sysOutType=errType) #test system
base_mse = (1.0 / len(error)) * sum(
[err[2]**2 for err in error if err <> None])
print 'MSE:', base_mse
return base_mse
def test4():
test_name = 'Full phis and majors Inputs'
print "*************************************"
print "TESTING: ", test_name
inMFs = input_7gaussMFs #system in
outMFs = output_9gaussMFs
defuzz = None
outForm = 'tri'
inDataForm = 'tri'
outDataForm = 'tri'
errType = 'fuzzy'
input_arrays, output_arrays = generate_MFs(inMFs, outMFs)
inputMFs = {
('VL_SYS_TYPE', 'phi'): copy.deepcopy(input_arrays['phi']),
('VL_SYS_PROP', 'phi'): copy.deepcopy(input_arrays['phi']),
('VL_SYS_DRV', 'phi'): copy.deepcopy(input_arrays['phi']),
('VL_SYS_TECH', 'phi'): copy.deepcopy(input_arrays['phi']),
('FWD_SYS_TYPE', 'phi'): copy.deepcopy(input_arrays['phi']),
('FWD_SYS_PROP', 'phi'): copy.deepcopy(input_arrays['phi']),
('FWD_SYS_DRV', 'phi'): copy.deepcopy(input_arrays['phi']),
('WING_SYS_TYPE', 'phi'): copy.deepcopy(input_arrays['phi']),
('ENG_SYS_TYPE', 'phi'): copy.deepcopy(input_arrays['phi']),
('VL_SYS_UNION', 'w'): copy.deepcopy(input_arrays['w']),
('VL_SYS_TYPE', 'TP'): copy.deepcopy(input_arrays['TP']),
('WING_SYS_TYPE', 'WS'): copy.deepcopy(input_arrays['WS']),
}
inputPARAMs = {
('VL_SYS_TYPE', 'phi'): copy.deepcopy(inMFs['phi']),
('VL_SYS_PROP', 'phi'): copy.deepcopy(inMFs['phi']),
('VL_SYS_DRV', 'phi'): copy.deepcopy(inMFs['phi']),
('VL_SYS_TECH', 'phi'): copy.deepcopy(inMFs['phi']),
('FWD_SYS_TYPE', 'phi'): copy.deepcopy(inMFs['phi']),
('FWD_SYS_PROP', 'phi'): copy.deepcopy(inMFs['phi']),
('FWD_SYS_DRV', 'phi'): copy.deepcopy(inMFs['phi']),
('WING_SYS_TYPE', 'phi'): copy.deepcopy(inMFs['phi']),
('ENG_SYS_TYPE', 'phi'): copy.deepcopy(inMFs['phi']),
('VL_SYS_UNION', 'w'): copy.deepcopy(inMFs['w']),
('VL_SYS_TYPE', 'TP'): copy.deepcopy(inMFs['TP']),
('WING_SYS_TYPE', 'WS'): copy.deepcopy(inMFs['WS']),
}
outputMFs = {'sys_phi': copy.deepcopy(output_arrays['sys_phi'])}
outputPARAMs = {'sys_phi': copy.deepcopy(outMFs['sys_phi'])}
combinedData = copy.deepcopy(combData)
#generate rules
with Timer() as t:
rule_grid = train_system(inputMFs,
outputMFs,
combinedData,
inDataMFs=inDataForm,
outDataMFs=outDataForm)
#write out FCL
write_fcl_file_FRBS(inputPARAMs, outputPARAMs, rule_grid, defuzz,
'test_sys_phi.fcl')
#get system
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, \
defuzz = build_fuzz_system('test_sys_phi.fcl')
sys = Fuzzy_System(inputs, outputs, rulebase, AND_operator, OR_operator,
aggregator, implication, defuzz)
print '=> ', t.secs, 'secs to build', len(sys.rulebase), 'rules'
#test system
with Timer() as t:
error = getError(combinedData,
sys,
inMF=inDataForm,
outMF=outDataForm,
sysOutType=errType)
print '=> ', t.secs, 'secs to check error'
print 'Total System Error:', sum([err[2] for err in error])
print 'Mean Square System Error:', (1.0 / len(error)) * sum(
[err[2]**2 for err in error])
print 'Root Mean Square System Error:', ((1.0 / len(error)) *
sum([err[2]**2
for err in error]))**0.5
#actual vs. predicted plot
plt.figure()
plt.title('Actual vs. Predicted at Max Alpha Cut' + test_name)
for err in error:
if outDataForm == 'gauss':
AC_actual = fuzzyOps.alpha_cut(0.8, [err[0][0], err[0][1]])
else:
AC_actual = fuzzyOps.alpha_at_val(err[0][0], err[0][1])
if outForm == 'gauss':
AC_pred = fuzzyOps.alpha_cut(0.8, (err[1][0], err[1][1]))
else:
AC_pred = fuzzyOps.alpha_at_val(err[1][0], err[1][1])
plt.scatter(AC_actual[0], AC_pred[0], marker='o', c='r')
plt.scatter(AC_actual[1], AC_pred[1], marker='x', c='b')
plt.plot([1, 9], [1, 9], '--k')
plt.xlim([1, 9])
plt.ylim([1, 9])
plt.xlabel('Actual')
plt.ylabel('Predicted')
#visuzlize system with random data point
#i = random.randrange(0, len(combinedData))
#inputs = {key[0]+"_"+key[1]:combinedData[i][0][key] for key in combinedData[i][0]}
#sys.run(inputs, TESTMODE=True)
#check random data points (9)
plt.figure()
plt.title('Random Tests:' + test_name)
for j in range(9):
i = random.randrange(0, len(combinedData))
inputs = {
key[0] + "_" + key[1]: combinedData[i][0][key]
for key in combinedData[i][0]
}
sysOut = sys.run(inputs)
sysOut = sysOut[sysOut.keys()[0]]
plt.subplot(3, 3, j + 1)
plt.plot(sysOut[0], sysOut[1], '-r')
plt.plot(combinedData[i][2][0], combinedData[i][2][1], '--k')
plt.ylim([0, 1.1])
plt.xlim([1, 9])
#actual vs. error plot
plt.figure()
plt.title('Actual (Centroid) vs. Error' + test_name)
cents = [fuzz.defuzz(err[0][0], err[0][1], 'centroid') for err in error]
plt.scatter(cents, [err[2] for err in error])
plt.xlabel('Actual (Centroid)')
plt.ylabel('Fuzzy Error')
def input_test(baselineMSE=None, inMFlist=[]):
test_name = 'input'
print "*************************************"
print "TESTING: ", test_name
inMFs = input_5gaussMFs #system in
outMFs = output_9gaussMFs
defuzz = None
outForm = 'gauss'
inDataForm = 'gauss'
outDataForm = 'gauss'
outType = 'fuzzy'
errCalc = 'dist'
input_arrays, output_arrays = generate_MFs(inMFs, outMFs)
inputMFs = {(d[1], d[3]): copy.deepcopy(input_arrays[d[3]])
for d in dataIn}
inputPARAMs = {(d[1], d[3]): copy.deepcopy(inMFs[d[3]]) for d in dataIn}
outputMFs = {'sys_phi': copy.deepcopy(output_arrays['sys_phi'])}
outputPARAMs = {'sys_phi': copy.deepcopy(outMFs['sys_phi'])}
t_base = 0.05 #threshold for
t_rem = 0.01 #threshold for removing a parameter (as percent of base MSE)
#GET BASELINE ERROR:
print "Getting baseline error for ", len(inputMFs), "inputs ... "
#random.shuffle(combData)
#
#random.shuffle(combData)
combDataVal = combData[:]
print len(combDataVal), "data points for validation."
#random.shuffle(combData)
combDataTrain = combData[:]
print len(combDataTrain), "data points for training."
combinedData = copy.deepcopy(
combDataTrain) #copy data to preserve raw data
valData = copy.deepcopy(combDataVal)
#if starting from scratch
if baselineMSE == None:
rule_grid = train_system(inputMFs,
outputMFs,
combinedData,
inDataMFs=inDataForm,
outDataMFs=outDataForm) #train rule grid
write_fcl_file_FRBS(inputPARAMs, outputPARAMs, rule_grid, defuzz,
'test_sys_phi.fcl') #write out FCL
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, defuzz = build_fuzz_system(
'test_sys_phi.fcl') #get system
sys = Fuzzy_System(inputs, outputs, rulebase, AND_operator,
OR_operator, aggregator, implication, defuzz)
error = getError(valData,
sys,
inMF=inDataForm,
outMF=outDataForm,
sysOutType=outType,
errType=errCalc) #test system
#print "TOTAL ERROR:", sum([x[2] for x in error])
base_mse = (1.0 / len([err for err in error if err[2] <> None])) * sum(
[err[2]**2 for err in error if err[2] <> None])
for inp in copy.deepcopy(
inputMFs
): #for each input, check if all antecedents are same MF and remove
input_antMFs = []
for rule in rule_grid:
for ant in rule:
if (ant[0],
ant[1]) == inp and (not ant[2] in input_antMFs):
input_antMFs.append(ant[2])
if len(input_antMFs) == 1:
print inp, "removed. No effect on consequent from antecedent MFs."
inputMFs.pop(inp)
inputPARAMs.pop(inp)
#if already baselined
else:
base_mse = baselineMSE #for
if len(inMFlist) > 0: #if inputs limited, reduce input list
print "Using reduced input set..."
for inp in copy.deepcopy(inputMFs):
if not inp in inMFlist:
inputMFs.pop(inp)
inputPARAMs.pop(inp)
print 'Baseline Mean Square System Error:', base_mse
inputMFs_rem = {} #store removed parameters
inputPARAMs_rem = {}
input_deltas = [] #track inputs and effects
input_count = len(inputMFs)
while True:
print "_________________________________________________________________"
print "CHECKING MODEL EFFECTS OF ALL INPUTS..."
for inp in copy.deepcopy(
inputMFs): #for each input get delta error for input removeal
combinedData = copy.deepcopy(
combDataTrain) #copy data to preserve raw data
valData = copy.deepcopy(combDataVal)
print "Checking Input", inp,
#REMOVE INPUT:
inputMFs_rem[inp] = inputMFs.pop(inp)
inputPARAMs_rem[inp] = inputPARAMs.pop(inp)
#GET NEW ERROR
rule_grid = train_system(inputMFs,
outputMFs,
combinedData,
inDataMFs=inDataForm,
outDataMFs=outDataForm) #train rule grid
write_fcl_file_FRBS(inputPARAMs, outputPARAMs, rule_grid, defuzz,
'test_sys_phi.fcl') #write out FCL
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, defuzz = build_fuzz_system(
'test_sys_phi.fcl') #get system
sys1 = Fuzzy_System(inputs, outputs, rulebase, AND_operator,
OR_operator, aggregator, implication, defuzz)
print len(sys1.inputs), 'remaining', len(rule_grid), 'rules.'
error = getError(valData,
sys1,
inMF=inDataForm,
outMF=outDataForm,
sysOutType=outType,
errType=errCalc) #test system
#print "TOTAL ERROR:", sum([x[2] for x in error])
new_mse = (1.0 / len([err
for err in error if err[2] <> None])) * sum([
err[2]**2
for err in error if err[2] <> None
])
del_mse = (new_mse - base_mse) / base_mse
print ' ==> Adjusted MSE: %.4f; normalized delta_MSE: %.6f' % (
new_mse, del_mse)
input_deltas.append([inp, del_mse])
#ADD INPUT BACK:
inputMFs[inp] = inputMFs_rem.pop(inp) #remove from removed lists
inputPARAMs[inp] = inputPARAMs_rem.pop(inp)
t_rem_ = copy.copy(t_rem)
print "---------------------------------------"
print "REMOVING INPUTS WITH LITTLE EFFECT..."
while True:
for pair in input_deltas: #make new model without inputs below t_rem threshold
if pair[1] < t_rem_:
inputMFs_rem[pair[0]] = inputMFs.pop(
pair[0]) #move inputs to removal list
inputPARAMs_rem[pair[0]] = inputPARAMs.pop(pair[0])
print "%d inputs out of %d remaining at removal delta of %.4f" % (
len(inputMFs), len(dataIn), t_rem_)
combinedData = copy.deepcopy(
combDataTrain) #copy data to preserve raw data
valData = copy.deepcopy(combDataVal)
#GET NEW SYSTEM ERROR
rule_grid = train_system(inputMFs,
outputMFs,
combinedData,
inDataMFs=inDataForm,
outDataMFs=outDataForm)
write_fcl_file_FRBS(inputPARAMs, outputPARAMs, rule_grid, defuzz,
'test_sys_phi.fcl') #write out FCL
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, \
defuzz = build_fuzz_system('test_sys_phi.fcl') #get system
sys = Fuzzy_System(inputs, outputs, rulebase, AND_operator,
OR_operator, aggregator, implication, defuzz)
print '%d inputs remaining %d rules at removal delta of %.4f' % (
len(sys.inputs), len(rule_grid), t_rem_)
error = getError(valData,
sys,
inMF=inDataForm,
outMF=outDataForm,
sysOutType=outType,
errType=errCalc) #test system
newbase_mse = (
1.0 / len([err for err in error if err[2] <> None])) * sum(
[err[2]**2 for err in error if err[2] <> None])
del_mse = (newbase_mse - base_mse) / base_mse
print 'New System MSE: %.4f; normalized delta_MSE: %.4f' % (
(1.0 / len(error)) * sum([err[2]**2
for err in error]), del_mse)
if (newbase_mse - base_mse) / base_mse < t_base or t_rem_ < 0.0001:
break #if model within t_base, break
else: #move all inputs back and adjust t_rem
for inp in copy.deepcopy(inputMFs_rem):
inputMFs[inp] = inputMFs_rem.pop(inp)
inputPARAMs[inp] = inputPARAMs_rem.pop(inp)
t_rem_ = t_rem_ - 0.5 * t_rem_
print "%d inputs out of %d remaining:" % (len(inputMFs), len(dataIn))
for inp in inputMFs:
print inp
if input_count == len(inputMFs):
print "No inputs removed... COMPLETE!"
break
else:
input_count = len(inputMFs)
#base_mse = newbase_mse
input_deltas = [] #track inputs and effects
inputMFs_rem = {} #clear out removed parameters
inputPARAMs_rem = {} #clear out removed parameters
print "REEVALUATING"
print "%d inputs out of %d3 remaining:" % (len(inputMFs), len(dataIn))
for inp in inputMFs:
print inp
def test5():
test_name = 'Full phi Inputs'
print "*************************************"
print "TESTING: ", test_name
inMFs = input_7gaussMFs #system in
outMFs = output_9gaussMFs
defuzz = None
outForm = 'tri'
inDataForm = 'tri'
outDataForm = 'tri'
errType = 'fuzzy'
input_arrays, output_arrays = generate_MFs(inMFs, outMFs)
inputMFs = { ('VL_SYS_TYPE', 'phi'): copy.deepcopy(input_arrays['phi']),
('VL_SYS_PROP', 'phi'): copy.deepcopy(input_arrays['phi']),
('VL_SYS_DRV', 'phi'): copy.deepcopy(input_arrays['phi']),
('VL_SYS_TECH', 'phi'): copy.deepcopy(input_arrays['phi']),
('FWD_SYS_TYPE', 'phi'): copy.deepcopy(input_arrays['phi']),
('FWD_SYS_PROP', 'phi'): copy.deepcopy(input_arrays['phi']),
('FWD_SYS_DRV', 'phi'): copy.deepcopy(input_arrays['phi']),
('WING_SYS_TYPE', 'phi'): copy.deepcopy(input_arrays['phi']),
('ENG_SYS_TYPE', 'phi'): copy.deepcopy(input_arrays['phi']),
}
inputPARAMs = { ('VL_SYS_TYPE', 'phi'): copy.deepcopy(inMFs['phi']),
('VL_SYS_PROP', 'phi'): copy.deepcopy(inMFs['phi']),
('VL_SYS_DRV', 'phi'): copy.deepcopy(inMFs['phi']),
('VL_SYS_TECH', 'phi'): copy.deepcopy(inMFs['phi']),
('FWD_SYS_TYPE', 'phi'): copy.deepcopy(inMFs['phi']),
('FWD_SYS_PROP', 'phi'): copy.deepcopy(inMFs['phi']),
('FWD_SYS_DRV', 'phi'): copy.deepcopy(inMFs['phi']),
('WING_SYS_TYPE', 'phi'): copy.deepcopy(inMFs['phi']),
('ENG_SYS_TYPE', 'phi'): copy.deepcopy(inMFs['phi']),
}
outputMFs = {'sys_phi' : copy.deepcopy(output_arrays['sys_phi'])}
outputPARAMs = {'sys_phi' : copy.deepcopy(outMFs['sys_phi'])}
combinedData = copy.deepcopy(combData)
#generate rules
with Timer() as t:
rule_grid = train_system(inputMFs, outputMFs, combinedData, inDataMFs=inDataForm, outDataMFs=outDataForm)
#write out FCL
write_fcl_file_FRBS(inputPARAMs, outputPARAMs, rule_grid, defuzz, 'test_sys_phi.fcl')
#get system
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, \
defuzz = build_fuzz_system('test_sys_phi.fcl')
sys = Fuzzy_System(inputs, outputs, rulebase, AND_operator, OR_operator, aggregator,
implication, defuzz)
print '=> ', t.secs, 'secs to build', len(sys.rulebase), 'rules'
#test system
with Timer() as t:
error = getError(combinedData, sys, inMF=inDataForm, outMF=outDataForm, sysOutType=errType)
print '=> ', t.secs, 'secs to check error'
print 'Total System Error:', sum([err[2] for err in error])
print 'Mean Square System Error:', (1.0/len(error))*sum([err[2]**2 for err in error])
print 'Root Mean Square System Error:', ( (1.0/len(error)) * sum([err[2]**2 for err in error]) )**0.5
#actual vs. predicted plot
plt.figure()
plt.title('Actual vs. Predicted at Max Alpha Cut'+test_name)
for err in error:
if outDataForm == 'gauss': AC_actual = fuzzyOps.alpha_cut(0.8, [err[0][0],err[0][1]])
else: AC_actual = fuzzyOps.alpha_at_val(err[0][0],err[0][1])
if outForm == 'gauss': AC_pred = fuzzyOps.alpha_cut(0.8, (err[1][0],err[1][1]))
else: AC_pred = fuzzyOps.alpha_at_val(err[1][0],err[1][1])
plt.scatter(AC_actual[0], AC_pred[0], marker='o', c='r')
plt.scatter(AC_actual[1], AC_pred[1], marker='x', c='b')
plt.plot([1,9],[1,9], '--k')
plt.xlim([1,9])
plt.ylim([1,9])
plt.xlabel('Actual')
plt.ylabel('Predicted')
#visuzlize system with random data point
#i = random.randrange(0, len(combinedData))
#inputs = {key[0]+"_"+key[1]:combinedData[i][0][key] for key in combinedData[i][0]}
#sys.run(inputs, TESTMODE=True)
#check random data points (9)
plt.figure()
plt.title('Random Tests:'+test_name)
for j in range(9):
i = random.randrange(0, len(combinedData))
inputs = {key[0]+"_"+key[1]:combinedData[i][0][key] for key in combinedData[i][0]}
sysOut = sys.run(inputs)
sysOut = sysOut[sysOut.keys()[0]]
plt.subplot(3,3,j+1)
plt.plot(sysOut[0], sysOut[1], '-r')
plt.plot(combinedData[i][2][0], combinedData[i][2][1], '--k')
plt.ylim([0,1.1])
plt.xlim([1,9])
#actual vs. error plot
plt.figure()
plt.title('Actual (Centroid) vs. Error'+test_name)
cents = [fuzz.defuzz(err[0][0], err[0][1], 'centroid') for err in error]
plt.scatter(cents, [err[2] for err in error])
plt.xlabel('Actual (Centroid)')
plt.ylabel('Fuzzy Error')
def input_test(baselineMSE=None, inMFlist=[]):
test_name = 'input'
print "*************************************"
print "TESTING: ", test_name
inMFs = input_5gaussMFs #system in
outMFs = output_9gaussMFs
defuzz = None
outForm = 'gauss'
inDataForm = 'gauss'
outDataForm = 'gauss'
outType = 'fuzzy'
errCalc='dist'
input_arrays, output_arrays = generate_MFs(inMFs, outMFs)
inputMFs = { (d[1], d[3]): copy.deepcopy(input_arrays[d[3]]) for d in dataIn }
inputPARAMs = { (d[1], d[3]): copy.deepcopy(inMFs[d[3]]) for d in dataIn }
outputMFs = {'sys_phi' : copy.deepcopy(output_arrays['sys_phi'])}
outputPARAMs = {'sys_phi' : copy.deepcopy(outMFs['sys_phi'])}
t_base = 0.05 #threshold for
t_rem = 0.01 #threshold for removing a parameter (as percent of base MSE)
#GET BASELINE ERROR:
print "Getting baseline error for ", len(inputMFs), "inputs ... "
#random.shuffle(combData)
#
#random.shuffle(combData)
combDataVal = combData[:]
print len(combDataVal), "data points for validation."
#random.shuffle(combData)
combDataTrain = combData[:]
print len(combDataTrain), "data points for training."
combinedData = copy.deepcopy(combDataTrain) #copy data to preserve raw data
valData = copy.deepcopy(combDataVal)
#if starting from scratch
if baselineMSE == None:
rule_grid = train_system(inputMFs, outputMFs, combinedData, inDataMFs=inDataForm, outDataMFs=outDataForm) #train rule grid
write_fcl_file_FRBS(inputPARAMs, outputPARAMs, rule_grid, defuzz, 'test_sys_phi.fcl') #write out FCL
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, defuzz = build_fuzz_system('test_sys_phi.fcl') #get system
sys = Fuzzy_System(inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, defuzz)
error = getError(valData, sys, inMF=inDataForm, outMF=outDataForm, sysOutType=outType, errType=errCalc) #test system
#print "TOTAL ERROR:", sum([x[2] for x in error])
base_mse = (1.0/len([err for err in error if err[2] <> None]))*sum([err[2]**2 for err in error if err[2] <> None])
for inp in copy.deepcopy(inputMFs): #for each input, check if all antecedents are same MF and remove
input_antMFs = []
for rule in rule_grid:
for ant in rule:
if (ant[0], ant[1]) == inp and (not ant[2] in input_antMFs):
input_antMFs.append(ant[2])
if len(input_antMFs) == 1:
print inp, "removed. No effect on consequent from antecedent MFs."
inputMFs.pop(inp)
inputPARAMs.pop(inp)
#if already baselined
else:
base_mse = baselineMSE #for
if len(inMFlist) > 0: #if inputs limited, reduce input list
print "Using reduced input set..."
for inp in copy.deepcopy(inputMFs):
if not inp in inMFlist:
inputMFs.pop(inp)
inputPARAMs.pop(inp)
print 'Baseline Mean Square System Error:', base_mse
inputMFs_rem = {} #store removed parameters
inputPARAMs_rem = {}
input_deltas = [] #track inputs and effects
input_count = len(inputMFs)
while True:
print "_________________________________________________________________"
print "CHECKING MODEL EFFECTS OF ALL INPUTS..."
for inp in copy.deepcopy(inputMFs): #for each input get delta error for input removeal
combinedData = copy.deepcopy(combDataTrain) #copy data to preserve raw data
valData = copy.deepcopy(combDataVal)
print "Checking Input", inp,
#REMOVE INPUT:
inputMFs_rem[inp] = inputMFs.pop(inp)
inputPARAMs_rem[inp] = inputPARAMs.pop(inp)
#GET NEW ERROR
rule_grid = train_system(inputMFs, outputMFs, combinedData, inDataMFs=inDataForm, outDataMFs=outDataForm) #train rule grid
write_fcl_file_FRBS(inputPARAMs, outputPARAMs, rule_grid, defuzz, 'test_sys_phi.fcl') #write out FCL
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, defuzz = build_fuzz_system('test_sys_phi.fcl') #get system
sys1 = Fuzzy_System(inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, defuzz)
print len(sys1.inputs), 'remaining', len(rule_grid), 'rules.'
error = getError(valData, sys1, inMF=inDataForm, outMF=outDataForm, sysOutType=outType, errType=errCalc) #test system
#print "TOTAL ERROR:", sum([x[2] for x in error])
new_mse = (1.0/len([err for err in error if err[2] <> None]))*sum([err[2]**2 for err in error if err[2] <> None])
del_mse = (new_mse - base_mse)/base_mse
print ' ==> Adjusted MSE: %.4f; normalized delta_MSE: %.6f' % (new_mse, del_mse)
input_deltas.append([inp, del_mse])
#ADD INPUT BACK:
inputMFs[inp] = inputMFs_rem.pop(inp) #remove from removed lists
inputPARAMs[inp] = inputPARAMs_rem.pop(inp)
t_rem_ = copy.copy(t_rem)
print "---------------------------------------"
print "REMOVING INPUTS WITH LITTLE EFFECT..."
while True:
for pair in input_deltas: #make new model without inputs below t_rem threshold
if pair[1] < t_rem_:
inputMFs_rem[pair[0]] = inputMFs.pop(pair[0]) #move inputs to removal list
inputPARAMs_rem[pair[0]] = inputPARAMs.pop(pair[0])
print "%d inputs out of %d remaining at removal delta of %.4f" % (len(inputMFs), len(dataIn), t_rem_)
combinedData = copy.deepcopy(combDataTrain) #copy data to preserve raw data
valData = copy.deepcopy(combDataVal)
#GET NEW SYSTEM ERROR
rule_grid = train_system(inputMFs, outputMFs, combinedData, inDataMFs=inDataForm, outDataMFs=outDataForm)
write_fcl_file_FRBS(inputPARAMs, outputPARAMs, rule_grid, defuzz, 'test_sys_phi.fcl') #write out FCL
inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, \
defuzz = build_fuzz_system('test_sys_phi.fcl') #get system
sys = Fuzzy_System(inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, defuzz)
print '%d inputs remaining %d rules at removal delta of %.4f' % (len(sys.inputs), len(rule_grid), t_rem_)
error = getError(valData, sys, inMF=inDataForm, outMF=outDataForm, sysOutType=outType, errType=errCalc) #test system
newbase_mse = (1.0/len([err for err in error if err[2] <> None]))*sum([err[2]**2 for err in error if err[2] <> None])
del_mse = (newbase_mse - base_mse)/base_mse
print 'New System MSE: %.4f; normalized delta_MSE: %.4f' % ((1.0/len(error))*sum([err[2]**2 for err in error]), del_mse)
if (newbase_mse - base_mse)/base_mse < t_base or t_rem_ < 0.0001: break #if model within t_base, break
else: #move all inputs back and adjust t_rem
for inp in copy.deepcopy(inputMFs_rem):
inputMFs[inp] = inputMFs_rem.pop(inp)
inputPARAMs[inp] = inputPARAMs_rem.pop(inp)
t_rem_ = t_rem_ - 0.5*t_rem_
print "%d inputs out of %d remaining:" % (len(inputMFs), len(dataIn))
for inp in inputMFs: print inp
if input_count == len(inputMFs):
print "No inputs removed... COMPLETE!"
break
else:
input_count = len(inputMFs)
#base_mse = newbase_mse
input_deltas = [] #track inputs and effects
inputMFs_rem = {} #clear out removed parameters
inputPARAMs_rem = {} #clear out removed parameters
print "REEVALUATING"
print "%d inputs out of %d3 remaining:" % (len(inputMFs), len(dataIn))
for inp in inputMFs: print inp
def test_NEFPROX_MackeyGlass():
t_max = 3000
dt = 1.0
beta = 0.2
tau = 17
n = 10.0
gamma = 0.1
t = [0.0]
x = [1.2]
while t[-1] < t_max:
x_tau = x[-1*min(len(x), tau+1)]
x_dot = beta*(x_tau/(1+x_tau**n)) - gamma*x[-1]
x.append(x[-1] + x_dot*dt)
t.append(t[-1]+dt)
plt.figure()
plt.plot( t[1118:2117], x[1118:2117] )
plt.show()
#collect data
inputData = []
for i in range(1118, 2117):
i1 = { ('DATA', 't_18'): [x[i-18]],
('DATA', 't_12'): [x[i-12]],
('DATA', 't_6'): [x[i-6]],
('DATA', 't_0'): [x[i-0]], }
o1 = [x[i+6]]
inputData.append([i1, None, o1])
print 'min:', min([id[2][0] for id in inputData])
print 'max:', max([id[2][0] for id in inputData])
minx = min([id[2][0] for id in inputData])
maxx = max([id[2][0] for id in inputData])
n = 7 #number of MFs
m = 3 #MF type (3,4)#
half_width = (maxx-minx)/float(n-1)
step_width = 2*half_width/(m-1)
MFs = []
for i in range(n):
range_start = minx+(i-1)*half_width
MFparams = [range_start + i*step_width for i in range(m)]
MFs.append(MFparams)
MFdict = {'A'+str(i): MFs[i] for i in range(len(MFs))}
triInputMFs = { ('DATA_t_18'): copy.deepcopy(MFdict),
('DATA_t_12'): copy.deepcopy(MFdict),
('DATA_t_6'): copy.deepcopy(MFdict),
('DATA_t_0'): copy.deepcopy(MFdict), }
triOutputMFs = {('t_plus_6'): MFdict }
inputMFs, outputMFs = generate_MFs(triInputMFs, triOutputMFs)
#append MFparams (just for neuro-fuzzy systems)
for inp in inputMFs:
for ling in inputMFs[inp]:
inputMFs[inp][ling] = inputMFs[inp][ling] + [triInputMFs[inp][ling]]
#append MFparams (just for neuro-fuzzy systems)
for otp in outputMFs:
for ling in outputMFs[otp]:
outputMFs[otp][ling] = outputMFs[otp][ling] + [triOutputMFs[otp][ling]]
#ranges for constraints
inLimits = {k:[minx - half_width - 0.1*(maxx-minx), maxx + half_width + 0.1*(maxx-minx)] for k in inputMFs}
outLimits = {k:[minx - half_width - 0.1*(maxx-minx), maxx + half_width + 0.1*(maxx-minx)] for k in outputMFs}
NFS = NEFPROX({}, {}, [], 'centroid') #system built
NFS, optData = train_NEFPROX(NFS, inputData[:700], inputData[700:], inputMFs, outputMFs,
inLimits, outLimits, sigma=0.0001, maxIterations=20)
write_fcl_file_NFS(NFS, 'mackey_glass_test.fcl')
#write report
f = open( "test_report.txt", 'w' )
for k in vars(optData):
f.write(str(k) + "=" + str(vars(optData)[k])+"\n")
f.close()
NFSoutput = []
for x1 in inputData:
inData = {inp[0]+'_'+inp[1]: sum(x1[0][inp])/len(x1[0][inp]) for inp in x1[0]}
output = NFS.run( inData )
NFSoutput.append(output.itervalues().next())
plt.figure()
plt.plot(t[1118:2117], x[1118:2117])
plt.plot(t[1118+6:2117+6], NFSoutput)
plt.show()
print "----- INPUT MFS -----"
for mf in NFS.inputMFs:
print mf, NFS.inputMFs[mf][2],
print "----- OUTPUT MFS -----"
for mf in NFS.outputMFs:
print mf, NFS.outputMFs[mf][2],
print "----- RULES -----"
for rule in NFS.layer2:
for inp in NFS.connect1to2[rule]: print inp,
print NFS.connect2to3[rule].keys()
NFS.plot()
import fuzzy_error
error = fuzzy_error.getError(copy.deepcopy(inputData[300:800]), NFS, inMF='sing', outMF='sing', sysOutType='crisp')
error = sorted(error, key=lambda x: x[0])
plt.figure()
plt.scatter([x[0] for x in error],[x[1] for x in error])
plt.plot([0.0,5.0],[0.0,5.0],'-r')
plt.xlim([min([x[0] for x in error]),max([x[0] for x in error])])
plt.ylim([min([x[0] for x in error]),max([x[0] for x in error])])
NFS.defuzz = None
error2 = fuzzy_error.getRangeError(copy.deepcopy(inputData[0:500]), NFS, inMF='sing', outMF='sing')
plt.figure()
for err in error2:
plt.plot([err[0], err[0]], err[1], '-o', c='#666666', lw=1.5, ms=0.5)
plt.plot([0.0,5.0],[0.0,5.0],'-r')
plt.xlim([min([x[0] for x in error]),max([x[0] for x in error])])
plt.ylim([min([x[0] for x in error]),max([x[0] for x in error])])
plt.show()
