Exemple #1
0
def test1():
    test_name = 'SYS: In:7-2 Out:9-2   DATA: In:3 Out:3'
    
    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_UNION', 'phi'):        copy.deepcopy(input_arrays['phi']),('FWD_SYS_UNION', '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']),('VL_SYS_PROP', 'sigma'):       copy.deepcopy(input_arrays['sigma']),    
                    ('VL_SYS_TYPE', 'e_d'):         copy.deepcopy(input_arrays['e_d']),('VL_SYS_DRV', 'eta_d'):        copy.deepcopy(input_arrays['eta_d']),('FWD_SYS_DRV', 'eta_d'):       copy.deepcopy(input_arrays['eta_d']),('FWD_SYS_PROP', 'eta_p'):      copy.deepcopy(input_arrays['eta_p']),
                }
    inputPARAMs = { ('VL_SYS_UNION', 'phi'):        copy.deepcopy(inMFs['phi']), ('FWD_SYS_UNION', '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']), ('VL_SYS_PROP', 'sigma'):       copy.deepcopy(inMFs['sigma']),    
                    ('VL_SYS_TYPE', 'e_d'):         copy.deepcopy(inMFs['e_d']),('VL_SYS_DRV', 'eta_d'):        copy.deepcopy(inMFs['eta_d']),('FWD_SYS_DRV', 'eta_d'):       copy.deepcopy(inMFs['eta_d']),('FWD_SYS_PROP', 'eta_p'):      copy.deepcopy(inMFs['eta_p']),
                }
    
    outputMFs = {'sys_phi' : copy.deepcopy(output_arrays['sys_phi'])}
    outputPARAMs = {'sys_phi' : copy.deepcopy(outMFs['sys_phi'])}
    
    combinedData = copy.deepcopy(data)
    print combinedData[0]
    #generate rules
    with Timer() as t:
        rule_grid = train_system(inputMFs, outputMFs, combinedData, 
                                 inDataMFs=inDataForm, outDataMFs=outDataForm,
                                 ruleMethod=3)
    
    #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')   
Exemple #2
0
    #SYSTEM_f = fuzz.trapmf(SYSTEM_f_x, [f[0],f[0],f[1],f[1]]) #trap input MFS
    #SYSTEM_f = fuzz.trimf(SYSTEM_f_x, [f[0],0.5*(f[0]+f[1]),f[1]]) #tri input MFS
    SYSTEM_f = fuzzyOps.rangeToMF(f, 'trap')
    
    LoD = [min(alt[6]), max(alt[6])]
    #WING_LoD_x = np.arange(0.9*LoD[0], 1.1*LoD[1], (1.1*LoD[1]-0.8*LoD[0])/100.0)
    #WING_LoD = fuzz.trapmf(WING_LoD_x, [LoD[0],LoD[0],LoD[1],LoD[1]]) #trap input MFS
    #WING_LoD = fuzz.trimf(WING_LoD_x, [LoD[0],0.5*(LoD[0]+LoD[1]),LoD[1]]) #tri input MFS
    WING_LoD = fuzzyOps.rangeToMF(LoD, 'trap')
    output = sys.run({'SYSTEM_f': SYSTEM_f, 
                      'WING_LoD': WING_LoD }, TESTMODE=True)
    output = output['sys_LoD']  


    #plot ranges from max alpha cuts
    outRange = fuzzyOps.alpha_at_val(output[0], output[1])
    
    #calculate overlap
    overlap = 100.*float(min(max(outRange), max(alt[7])) - max(min(outRange), min(alt[7])))/ \
              max( max(outRange)-min(outRange) , max(alt[7])-min(alt[7]) )
    print alt[0], overlap, '% overlap'
    
    ax1.bar(outRange[0], 0.3, width=outRange[1]-outRange[0], bottom=ps_inputs.index(alt)+0.7, color='r')
    ax1.bar(alt[7][0],   0.3, width=alt[7][1]-alt[7][0],     bottom=ps_inputs.index(alt)+1.0, color='b')
    ax1.text(max(max(outRange),max(alt[7]))+0.5, ps_inputs.index(alt)+0.9, str(round(overlap,1))+'%',
             fontsize=10)
    
    #plot actual outputs
    i = ps_inputs.index(alt)
    ax2[(i-(i%2))/2, i%2].plot(output[0], output[1], '-r')
    exp_x = np.arange(0.9*min(alt[7]), 1.1*max(alt[7]), (max(alt[7])-min(alt[7]))/50.)
Exemple #3
0
    SYSTEM_f = fuzzyOps.rangeToMF(f, 'trap')

    LoD = [min(alt[6]), max(alt[6])]
    #WING_LoD_x = np.arange(0.9*LoD[0], 1.1*LoD[1], (1.1*LoD[1]-0.8*LoD[0])/100.0)
    #WING_LoD = fuzz.trapmf(WING_LoD_x, [LoD[0],LoD[0],LoD[1],LoD[1]]) #trap input MFS
    #WING_LoD = fuzz.trimf(WING_LoD_x, [LoD[0],0.5*(LoD[0]+LoD[1]),LoD[1]]) #tri input MFS
    WING_LoD = fuzzyOps.rangeToMF(LoD, 'trap')
    output = sys.run({
        'SYSTEM_f': SYSTEM_f,
        'WING_LoD': WING_LoD
    },
                     TESTMODE=True)
    output = output['sys_LoD']

    #plot ranges from max alpha cuts
    outRange = fuzzyOps.alpha_at_val(output[0], output[1])

    #calculate overlap
    overlap = 100.*float(min(max(outRange), max(alt[7])) - max(min(outRange), min(alt[7])))/ \
              max( max(outRange)-min(outRange) , max(alt[7])-min(alt[7]) )
    print alt[0], overlap, '% overlap'

    ax1.bar(outRange[0],
            0.3,
            width=outRange[1] - outRange[0],
            bottom=ps_inputs.index(alt) + 0.7,
            color='r')
    ax1.bar(alt[7][0],
            0.3,
            width=alt[7][1] - alt[7][0],
            bottom=ps_inputs.index(alt) + 1.0,
def testMFs(tData, vData, test_name, inMFs, outMFs, outForm, inDataForm, outDataForm, 
            defuzz=None, sysOutType="fuzzy", errType="dist"):
    
    print "*************************************"
    print "TESTING:  ", test_name
    print len(tData), "training points", len(vData), "validation points."
    #inMFs = input_5gaussMFs       #system in
    #outMFs = output_7gaussMFs
    #defuzz = None
    
    #outForm = 'gauss'
    #inDataForm = 'gauss'
    #outDataForm = 'gauss'
    #errType = 'fuzzy'
    
    input_arrays, output_arrays = generate_MFs(inMFs, outMFs)
    
    inputMFs = { inp: copy.deepcopy(input_arrays[inp[1]])  for inp in inputList }
    inputPARAMs = {inp: copy.deepcopy(inMFs[inp[1]])  for inp in inputList }
    
    outputMFs = {'sys_FoM' : copy.deepcopy(output_arrays['sys_FoM'])}
    outputPARAMs = {'sys_FoM' : copy.deepcopy(outMFs['sys_FoM'])}
        
    combinedData = copy.deepcopy(tData)
    
    #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_fom.fcl')
    
    #get system
    inputs, outputs, rulebase, AND_operator, OR_operator, aggregator, implication, \
        defuzz = build_fuzz_system('test_sys_fom.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
    testData = copy.deepcopy(vData)
    
    with Timer() as t:
        error = getError(testData, sys, inMF=inDataForm, outMF=outDataForm, sysOutType=sysOutType, errType=errType)
        
    print '=> ', t.secs, 'secs to check error'
    print 'Total System Error:', sum([err[2] for err in error if err[2] <> None])
    print 'Mean Square System Error:', (1.0/ len([err for err in error if err[2] <> None]) ) * \
                                       sum([err[2]**2 for err in error if err[2] <> None])
    print 'Root Mean Square System Error:', ( ( 1.0/len([err for err in error if err[2] <> None]) ) *sum([err[2]**2 for err in error if err[2] <> None]) )**0.5
    
    
    #check random data points for time
    check = 15
    t_tot = 0.0
    for j in range(check):
        i = random.randrange(0, len(testData))
        inputs = {key[0]+"_"+key[1]:testData[i][0][key] for key in testData[i][0]}
        with Timer() as t:
            sysOut = sys.run(inputs)
        t_tot = t_tot + float(t.secs)
    print 'Average system time of %d points => %.5f s' % (check, t_tot/check)
    print '                                 => %.5f s per rule' % ((t_tot/check)/len(sys.rulebase))
    
    
    
    #actual vs. predicted plot
    alpha = 0.7
    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(alpha, [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(alpha, (err[1][0],err[1][1]))
        else: AC_pred = fuzzyOps.alpha_at_val(err[1][0],err[1][1])
        
        if AC_actual <> None and AC_pred <> None: 
            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([0,9],[0,9], '--k')     
    plt.xlim([0.4,1.0])
    plt.ylim([0.4, 1.0])
    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 for time
    """
    plotData = copy.deepcopy(vData)
    plt.figure()
    plt.title('Random Tests:'+test_name)
    for j in range(9):
        i = random.randrange(0, len(plotData))
        inputs = {key[0]+"_"+key[1]:plotData[i][0][key] for key in plotData[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(plotData[i][2][0], plotData[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')
    
    plt.show()
    
    return len(sys.rulebase), (1.0/len(error))*sum([err[2]**2 for err in error])
Exemple #5
0
def getRangeError(truthData, system, inMF='sing', outMF='sing'):
    """
    Get a system's error against a set of truth data using Range outputs. (MUST 
    BE SYSTEM WITH FUZZY OUTPUT, NOT CRISP). For crisp (sing) outMF, error is 
    distance outside alpha-cut at maximum of system's output fuzzy membership fucntion.
    For fuzzy outMF (gauss, tri, trap), gets output alpha-cut range at alpha=1.0, 
    and error is error function by fuzErrorAC.
    ------INPUTS------
    truthData - list
        truth data to compare system output to in form:
                [Quant Input, Qual Input, Output]
                with inputs as {('input'): [values], ('input'): [values], ... }
                and outputs as [output value(s)]
    system : module
        instance of system to get error on !MUST BE FUZZY OUTPUT!
    inMF : string
        type of MF to use for input data ('sing', 'tri', 'trap', 'gauss')
    outMF : string
        type of MF to use for output data ('sing', 'tri', 'trap', 'gauss')
    sysOutType : string
        type of output to use from system ('crisp' or 'fuzzy')
        converts fuzzy outputs to crisp via 'centroid' defuzzification
    ------OUTPUTS------
    error : list
        list of [truth[min,max], truth[min,max], error]
    """
    q = 0 #use quantitative data
    
    error = [] #track error for output

    #Turn Data to MFs
    for point in truthData:
        #create input MFs for each input
        for inp in point[q]:
            if inMF == 'sing':   #create singleton MF
                point[q][inp] = sum(point[q][inp])/len(point[q][inp]) #get mean of range (single value)
            elif inMF == 'tri':   #create triangluar MF (min, avg, max)
                x_range = np.arange(point[q][inp][0]*0.9, point[q][inp][1]*1.1, 
                                    (point[q][inp][1]*1.1 - point[q][inp][0]*0.9)/150)
                y_vals = fuzz.trimf(x_range, [point[q][inp][0], sum(point[q][inp])/len(point[q][inp]), point[q][inp][1]])
                point[q][inp] = [x_range, y_vals]
            elif inMF == 'trap':  #create traoeziodal MF (min, min, max, max)
                x_range = np.arange(point[q][inp][0]*0.9, point[q][inp][1]*1.1, 
                                    (point[q][inp][1]*1.1 - point[q][inp][0]*0.9)/150)
                y_vals = fuzz.trimf(x_range, [dataIt[q][inp][0], point[q][inp][0],
                                    point[q][inp][0], point[q][inp][1]])
                point[q][inp] = [x_range, y_vals]    
        #create output MFs
        if outMF == 'sing':   #create singleton MF
            point[2] = sum(point[2])/len(point[2]) #get average for singleton value
        elif outMF == 'tri':   #create singleton MF
            x_range = np.arange(point[2][0]*0.9, point[2][1]*1.1, 
                                (point[2][1]*1.1 - point[2][0]*0.9)/150)
            y_vals = fuzz.trimf(x_range, [point[2][0], sum(point[2])/len(point[2]), point[2][1]])
            point[2] = [x_range, y_vals]        
        elif outMF == 'trap':   #create singleton MF
            x_range = np.arange(point[2][0]*0.9, point[2][1]*1.1, (point[2][1]*1.1 - point[2][0]*0.9)/150)
            y_vals = fuzz.trimf(x_range, [point[2][0], point[2][0], point[2][1], point[2][1]])
            point[2] = [x_range, y_vals]
    
    #Get system responses to data
    for point in truthData:
        inputs = {key[0]+"_"+key[1]:point[0][key] for key in point[0]}
        output = system.run(inputs)
        if isinstance(output, dict): output = output.itervalues().next()
        point.append(output)
    
    for point in truthData:             
        #get error
        if not outMF=='sing':  #if data is fuzzy
            err = fuzzy_error.fuzErrorAC(point[2], point[3])
            truthRange = fuzzyOps.alpha_at_val(point[2][0], point[2][1], alpha=1.0)
            outRange = fuzzyOps.alpha_at_val(point[3], point[3])
        else:
            outRange = fuzzyOps.alpha_at_val(point[3][0], point[3][1])
            
            if None in outRange: err = None
            elif point[2] >= min(outRange) and point[2] <= max(outRange):
                err = 0
            elif point[2] < min(outRange):
                err = point[2] - min(outRange)
            elif point[2] > max(outRange):
                err = point[2] - max(outRange)
            truthRange = point[2]
            
        error.append([truthRange, outRange, err])
        
    return error   
Exemple #6
0
def testMFs(tData, vData, test_name, inMFs, outMFs, outForm, inDataForm, outDataForm, 
            defuzz=None, sysOutType="fuzzy", errType="dist", plot=True):
    
    print "*************************************"
    print "TESTING:  ", test_name
    print len(tData), "training points", len(vData), "validation points."
    #inMFs = input_5gaussMFs       #system in
    #outMFs = output_7gaussMFs
    #defuzz = None
    
    #outForm = 'gauss'
    #inDataForm = 'gauss'
    #outDataForm = 'gauss'
    #errType = 'fuzzy'
    
    input_arrays, output_arrays = generate_MFs(inMFs, outMFs)
    
    inputMFs = { inp: copy.deepcopy(input_arrays[inp[1]])  for inp in inputList }
    inputPARAMs = {inp: copy.deepcopy(inMFs[inp[1]])  for inp in inputList }
    
    outputMFs = {'sys_phi' : copy.deepcopy(output_arrays['sys_phi'])}
    outputPARAMs = {'sys_phi' : copy.deepcopy(outMFs['sys_phi'])}
        
    combinedData = copy.deepcopy(tData)
    
    #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
    testData = copy.deepcopy(vData)
    
    with Timer() as t:
        error = getError(testData, sys, inMF=inDataForm, outMF=outDataForm, sysOutType=sysOutType, errType=errType)
        
    print '=> ', t.secs, 'secs to check error'
    print 'Total System Error:', sum([err[2] for err in error if err[2] <> None])
    print 'Mean Square System Error:', sum([err[2]**2 for err in error if err[2] <> None]) / len([err for err in error if err[2] <> None]) 
    print 'Root Mean Square System Error:', ( sum([err[2]**2 for err in error if err[2] <> None]) / len([err for err in error if err[2] <> None])  )**0.5
    
    
    #check random data points for time
    check = 15
    t_tot = 0.0
    for j in range(check):
        i = random.randrange(0, len(testData))
        inputs = {key[0]+"_"+key[1]:testData[i][0][key] for key in testData[i][0]}
        with Timer() as t:
            sysOut = sys.run(inputs)
        t_tot = t_tot + float(t.secs)
    print 'Average system time of %d points => %.5f s' % (check, t_tot/check)
    print '                                 => %.5f s per rule' % ((t_tot/check)/len(sys.rulebase))
    
    
    #actual vs. predicted plot
    alpha = 0.7
    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(alpha, [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(alpha, (err[1][0],err[1][1]))
        else: AC_pred = fuzzyOps.alpha_at_val(err[1][0],err[1][1])
        
        if AC_actual <> None and AC_pred <> None: 
            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 for time
    """
    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')
    """
    return len(sys.rulebase), sum([err[2]**2 for err in error if err[2] <> None]) / len([err for err in error if err[2] <> None])