.

v4_class.py

         output.append(values[i : (i + time_steps)])
     return np.stack(output)
 
-def AtLeastOneTrue(x):
-    for i in range(NumFeatures):
-        if x[i]:
-            return True
-    return False
-
-
-def anomalyMetric(th,ts,testList):  # first of list is non failure data
-    # FP, TP: false/true positive
-    # TN, FN: true/false negative
-    # Sensitivity (recall): probab failure detection if data is fail: TP/(TP+FN)
-    # Specificity: true negative ratio given  data is OK: TN/(TN+FP)
-    # Accuracy: Rate of correct predictions:  (TN+TP)/(TN+TP+FP+FN)
-    # Precision: Rate of positive results:  TP/(TP+FP)  
-    # F1-score: predictive performance measure: 2*Precision*Sensitity/(Precision+Sensitity)
-    # F2-score: predictive performance measure:  2*Specificity*Sensitity/(Specificity+Sensitity)
-    x_test = create_sequences(testList[0],ts)
-    x_test_pred = model.predict(x_test)
-    test_mae_loss = np.mean(np.abs(x_test_pred - x_test), axis=1)
-    anomalies = test_mae_loss > th
-    count=0
-    for i in range(anomalies.shape[0]):
-        if AtLeastOneTrue(anomalies[i]):
-            count+=1
-    FP=count
-    TN=anomalies.shape[0]-count
-    count=0
-    TP=np.zeros((NumberOfFailures))
-    FN=np.zeros((NumberOfFailures))
-    Sensitivity=np.zeros((NumberOfFailures))
-    Precision=np.zeros((NumberOfFailures))
-    for i in range(1,len(testList)):
-        x_test = create_sequences(testList[i],ts)
-        x_test_pred = model.predict(x_test)
-        test_mae_loss = np.mean(np.abs(x_test_pred - x_test), axis=1)
-        anomalies = test_mae_loss > th
-        count=0
-        for j in range(anomalies.shape[0]):
-            if AtLeastOneTrue(anomalies[j]):
-                count+=1
-        TP[i-1] = count
-        FN[i-1] = anomalies.shape[0]-count
-        Sensitivity[i-1]=TP[i-1]/(TP[i-1]+FN[i-1])
-        Precision[i-1]=TP[i-1]/(TP[i-1]+FP)
-    GlobalSensitivity=TP.sum()/(TP.sum()+FN.sum())
-    Specificity=TN/(TN+FP)
-    Accuracy=(TN+TP.sum())/(TN+TP.sum()+FP+FN.sum())
-    GlobalPrecision=TP.sum()/(TP.sum()+FP)
-    F1Score= 2*GlobalPrecision*GlobalSensitivity/(GlobalPrecision+GlobalSensitivity)
-    F2Score = 2*Specificity*GlobalSensitivity/(Specificity+GlobalSensitivity)
-    print("Global Precision: ",GlobalPrecision)
-    print("Precision: ",Precision)
-    print("Global Sensitivity: ",GlobalSensitivity)
-    print("Sensitivity: ",Sensitivity)
-    #print("Specifity: ",Specificity)
-    #print("Accuracy: ",Accuracy)
-    print("F1Score: ",F1Score)
-    #print("F2Score: ",F2Score)
-    #print("FP: ",FP)
-    #return Sensitivity+Specifity
-    return F1Score
-
 
 
 def listToString(l):
     testRanges.append([r,r+datalist[i].shape[0]-int(options.timesteps)])
     r+=datalist[i].shape[0]-int(options.timesteps)
 
+testClasses=[0,1,2,3,4]
+
+if not len(testClasses)==len(testRanges):
+    print("ERROR:  testClasses and testRanges must have same length")
+    exit(0)
 
 x_test_predict=[]
 for m in range(NumberOfFailures+1):
 test_mae_loss =[]
 for m in range(NumberOfFailures+1):
     test_mae_loss.append(np.mean(np.abs(x_test_predict[m,:,:,:] - x_test), axis=1))
+
 test_mae_loss=np.array((test_mae_loss))
 test_mae_loss_average=np.mean(test_mae_loss,axis=2)  # average over features
 classes=np.argmin(test_mae_loss_average,axis=0)
     y.append([])
 for j in range(NumberOfFailures+1):
     for k in range(testRanges[j][0],testRanges[j][1]):
-        if not  classes[k]==j:
+        if not  classes[k]==testClasses[j]:
             x[classes[k]].append(k)
             y[classes[k]].append(x_test[k,0,indexesToPlot[0]]*stdevs[0]+means[0])
 
 
-
 def plotData4():
     NumFeaturesToPlot=len(indexesToPlot)
     plt.rcParams.update({'font.size': 16})
     plt.show()
 
 
-plotData4()
 
 ##   It remains to implemenent anomaly metrics for each failure type
+def anomalyMetric(classes,testranges,testclasses):  
+    # FP, TP: false/true positive
+    # TN, FN: true/false negative
+    # Sensitivity (recall): probab failure detection if data is fail: TP/(TP+FN)
+    # Precision: Rate of positive results:  TP/(TP+FP)  
+    # F1-score: predictive performance measure: 2*Precision*Sensitity/(Precision+Sensitity)
 
+    print(classes)
+
+anomalyMetric(classes,testRanges,testClasses)
+plotData4()
 exit(0)