.

paper/fig.tex

@@ -0,0 +1,74 @@
+\documentclass{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath, amssymb, latexsym}
+\DeclareMathOperator{\ReLU}{ReLU}
+ 
+\usepackage{tikz}
+\usepackage{xcolor}
+\definecolor{fc}{HTML}{1E90FF}
+\definecolor{h}{HTML}{228B22}
+\definecolor{bias}{HTML}{87CEFA}
+\definecolor{noise}{HTML}{8B008B}
+\definecolor{conv}{HTML}{FFA500}
+\definecolor{pool}{HTML}{B22222}
+\definecolor{up}{HTML}{B22222}
+\definecolor{view}{HTML}{FFFFFF}
+\definecolor{bn}{HTML}{FFD700}
+\tikzset{fc/.style={black,draw=black,fill=fc,rectangle,minimum height=1cm}}
+\tikzset{h/.style={black,draw=black,fill=h,rectangle,minimum height=1cm}}
+\tikzset{bias/.style={black,draw=black,fill=bias,rectangle,minimum height=1cm}}
+\tikzset{noise/.style={black,draw=black,fill=noise,rectangle,minimum height=1cm}}
+\tikzset{conv/.style={black,draw=black,fill=conv,rectangle,minimum height=1cm}}
+\tikzset{conv2/.style={black,draw=black,fill=conv,rectangle,minimum height=1cm}}
+\tikzset{conv2t/.style={black,draw=black,fill=green,rectangle,minimum height=1cm}}
+\tikzset{pool/.style={black,draw=black,fill=pool,rectangle,minimum height=1cm}}
+\tikzset{drop/.style={black,draw=black,fill=pool,rectangle,minimum height=1cm}}
+\tikzset{up/.style={black,draw=black,fill=up,rectangle,minimum height=1cm}}
+\tikzset{view/.style={black,draw=black,fill=view,rectangle,minimum height=1cm}}
+\tikzset{bn/.style={black,draw=black,fill=bn,rectangle,minimum height=1cm}}
+ 
+\usepackage{xspace}
+\newcommand*{\eg}{\emph{e.g.}\@\xspace}
+\newcommand*{\Eg}{\emph{E.g.}\@\xspace}
+\newcommand*{\ie}{\emph{i.e.}\@\xspace}
+\newcommand*{\etc}{\emph{etc.}\@\xspace}
+\newcommand*{\etal}{\emph{et al.}\@\xspace}
+\newcommand*{\cf}{\emph{cf.}\@\xspace}
+\newcommand*{\vs}{\emph{vs.}\@\xspace}
+ 
+\begin{document}
+ 
+\begin{figure}
+  \centering
+  \hspace*{-0.75cm}
+  \begin{tikzpicture}
+    \node (y) at (0,0) {$\mathbf{X}$};
+    \node (yl) at (0,-3) {.};
+ 
+    \node[conv,rotate=90,minimum width=4.5cm] (conv1) at (1.25,0) {\small$\text{Conv1D}_{64, 7, 2}$\,+\,$\ReLU$};
+    \node[drop,rotate=90,minimum width=3.5cm] (drop1) at (3.,0) {\small$\text{DropOut}$};
+    \node[conv2,rotate=90,minimum width=3.5cm] (conv2) at (4.75,0) {\small$\text{Conv1D}_{32, 7, 2}$\,+\,$\ReLU$};
+    \node[conv2t,rotate=90,minimum width=3.5cm] (convt) at (6.5,0) {\small$\text{Conv1DT}_{32, 7, 2}$\,+\,$\ReLU$};
+    \node[drop,rotate=90,minimum width=3.5cm] (drop2) at (8.25,0) {\small$\text{DropOut}$};
+    \node[conv2t,rotate=90,minimum width=4.5cm] (conv2t) at (10,0) {\small$\text{Conv1DT}_{64, 7, 2}$\,+\,$\ReLU$};
+    \node[conv2t,rotate=90,minimum width=3.5cm] (conv3t) at (11.75,0) {\small$\text{Conv1DT}_{22, 7, 1}$};
+    
+    \node (ry) at (13,0) {$\mathbf{\hat{X}}$};
+    \node (ryl) at (13,0-3) {.};
+    
+    \draw[->,ultra thick] (y) -- (conv1);
+    \draw[->,ultra thick] (conv1) -- (drop1);
+    \draw[->,ultra thick] (drop1) -- (conv2);
+    \draw[->,ultra thick] (conv2) -- (convt);
+    \draw[->,ultra thick] (convt) -- (drop2);
+    \draw[<-,ultra thick] (conv2t) -- (drop2);
+    \draw[->,ultra thick] (conv2t) -- (conv3t);
+    \draw[->,ultra thick] (conv3t) -- (ry);
+    \draw[dashed] (y) -- (yl);
+    \draw[dashed] (ry) -- (ryl);
+    \draw[dashed,<->] (yl)  to node[above] {$\overline{|\mathbf{\hat{X}}-\mathbf{X}|}$} (ryl);
+ 
+  \end{tikzpicture}
+\end{figure}
+
+\end{document}

v1.py

@@ -8,6 +8,7 @@ import os.path
 import pickle
 from keras import layers
 from optparse import OptionParser
+import copy
 
 
 parser = OptionParser()
@@ -32,7 +33,7 @@ for i in range(NumberOfFailures+1):
     datafiles.append([])
 
 # Next set of ddata corresponds to Freezer, SP=-26
-datafiles[0]=['2024-08-07_5_','2024-08-08_5_'] 
+datafiles[0]=['2024-08-07_5_','2024-08-08_5_','2025-01-25_5_','2025-01-26_5_'] 
 datafiles[1]=['2024-12-11_5_', '2024-12-12_5_','2024-12-13_5_','2024-12-14_5_','2024-12-15_5_'] 
 datafiles[2]=['2024-12-18_5_','2024-12-19_5_'] 
 datafiles[3]=['2024-12-21_5_','2024-12-22_5_','2024-12-23_5_','2024-12-24_5_','2024-12-25_5_','2024-12-26_5_'] 
@@ -44,7 +45,7 @@ datafiles[4]=['2024-12-28_5_','2024-12-29_5_','2024-12-30_5_','2024-12-31_5_','2
 # Seems to be incoropored in new tests
 
 features=['r1 s1','r1 s4','r1 s5','pa1 apiii']
-features=['r1 s1','r1 s2','r1 s3','r1 s4','r1 s5','r1 s6','r1 s7','r1 s8','r1 s9','r1 s10','r2 s1','r2 s2','r2 s3','r2 s4','r2 s5','r2 s6','r2 s7','r2 s8','r2 s9','pa1 apiii','tc s1','tc s2']
+#features=['r1 s1','r1 s2','r1 s3','r1 s4','r1 s5','r1 s6','r1 s7','r1 s8','r1 s9','r1 s10','r2 s1','r2 s2','r2 s3','r2 s4','r2 s5','r2 s6','r2 s7','r2 s8','r2 s9','pa1 apiii','tc s1','tc s2']
 
 #features=['r2 s2', 'tc s1','r1 s10','r1 s6','r2 s8']
 
@@ -116,15 +117,16 @@ def plotData():
     #axes[1].legend()
     #axes[0].set_ylabel(features[0])
     #axes[1].set_ylabel(features[1])
-    #plt.show()
+    plt.show()
 
 #plotData()
+#exit(0)
 
 
 NumFilters=64
 KernelSize=7
-DropOut=0.1
-ThresholdFactor=1.7
+DropOut=0.2
+ThresholdFactor=0.9
 TIME_STEPS = 48  # This is a trade off among better performance (high) and better response delay (low)
 def create_sequences(values, time_steps=TIME_STEPS):
     output = []
@@ -191,6 +193,7 @@ else:
 x_train_pred=model.predict(x_train[0])
 train_mae_loss=np.mean(np.abs(x_train_pred - x_train[0]), axis=1)
 threshold=np.max(train_mae_loss,axis=0)
+thresholdOrig=copy.deepcopy(threshold)
 
 print("Threshold : ",threshold)
 threshold=threshold*ThresholdFactor
@@ -199,7 +202,8 @@ threshold=threshold*ThresholdFactor
 
 #  1st scenario. Detect only anomaly.  Later, we will classiffy it
 # Test data=  testnormal + testfail1 + testtail2 + testfail3 + testfail4 + testnormal
-d=np.vstack((dataTestNorm[0],dataTestNorm[1],dataTestNorm[2],dataTestNorm[3],dataTestNorm[4],dataTestNorm[0]))
+#d=np.vstack((dataTestNorm[0],dataTestNorm[1],dataTestNorm[2],dataTestNorm[3],dataTestNorm[4],dataTestNorm[0]))
+d=np.vstack((dataTestNorm[0],dataTestNorm[1],dataTestNorm[2],dataTestNorm[3],dataTestNorm[4]))
 
 x_test = create_sequences(d)
 x_test_pred = model.predict(x_test)
@@ -215,7 +219,8 @@ for i in range(1,NumberOfFailures+1):
     testRanges.append([r,rnext] )
     r=rnext
 
-testRanges.append([r, x_test.shape[0]+TIME_STEPS  ])
+# Drop the last TIME_STEPS for plotting
+testRanges[NumberOfFailures][1]=testRanges[NumberOfFailures][1]-TIME_STEPS
 
 
 def AtLeastOneTrue(x):
@@ -239,51 +244,54 @@ for i in range(anomalies.shape[0]):
 colorline=['violet','lightcoral','cyan','lime','grey']
 colordot=['darkviolet','red','blue','green','black']
 
-featuresToPlot=['r1 s1','r1 s2','r1 s3','pa1 apiii']
-#featuresToPlot=features
+#featuresToPlot=['r1 s1','r1 s2','r1 s3','pa1 apiii']
+featuresToPlot=features
 
 indexesToPlot=[]
 for i in featuresToPlot:
     indexesToPlot.append(features.index(i))
 
-def plotData2():
+def plotData3():
     NumFeaturesToPlot=len(indexesToPlot)
+    plt.rcParams.update({'font.size': 16})
     fig, axes = plt.subplots(
-        nrows=NumFeaturesToPlot, ncols=1, figsize=(25, 20), dpi=80, facecolor="w", edgecolor="k",sharex=True
+        nrows=NumFeaturesToPlot, ncols=1, figsize=(15, 10), dpi=80, facecolor="w", edgecolor="k",sharex=True
     )
     for i in range(NumFeaturesToPlot):
         init=0
-        end=len(x_train[0])
-        axes[i].plot(range(init,end),x_train[0][:,0,indexesToPlot[i]],label="normal train")
-        init=end
-        end+=testRanges[0][1]
-        axes[i].plot(range(init,end),x_test[testRanges[0][0]:testRanges[0][1],0,indexesToPlot[i]],label="normal test")
+        end=testRanges[0][1]
+        axes[i].plot(range(init,end),x_test[testRanges[0][0]:testRanges[0][1],0,indexesToPlot[i]],label="No fail")
         init=end
         end+=(testRanges[1][1]-testRanges[1][0])
         for j in range(1,NumberOfFailures+1):
             axes[i].plot(range(init,end),x_test[testRanges[j][0]:testRanges[j][1],0,indexesToPlot[i]],label="fail type "+str(j), color=colorline[j-1])
-            init=end
-            end+=(testRanges[j+1][1]-testRanges[j+1][0])
-        # Shift TIME_STEPS because detection is performed at the end of time serie
-        trail=np.hstack((x_test[:,0,indexesToPlot[i]], x_test[-1:,1:TIME_STEPS,indexesToPlot[i]].reshape(TIME_STEPS-1)))
-        axes[i].plot(len(x_train[0])+np.array(anomalous_data_indices)+TIME_STEPS,trail[np.array(anomalous_data_indices)+TIME_STEPS],color='grey',marker='.',linewidth=0,label="abnormal detection" )
-
-        init=end-(testRanges[NumberOfFailures+1][1]-testRanges[NumberOfFailures+1][0])
-        end=init+(testRanges[0][1]-testRanges[0][0])
-        axes[i].plot(range(init,end),x_test[testRanges[0][0]:testRanges[0][1],0,indexesToPlot[i]],color='orange')
+            if j<NumberOfFailures:
+                init=end
+                end+=(testRanges[j+1][1]-testRanges[j+1][0])
+        x=[]
+        y=[]
+        for k in anomalous_data_indices:
+            if (k+TIME_STEPS)<x_test.shape[0]:
+                x.append(k+TIME_STEPS)
+                y.append(x_test[k+TIME_STEPS,0,indexesToPlot[i]])
+        axes[i].plot(x,y ,color='grey',marker='.',linewidth=0,label="fail detection" )
 
         if i==0:
-            axes[i].legend(bbox_to_anchor=(1, 0.5))
+            axes[i].legend(bbox_to_anchor=(0.9, 0.4))
         axes[i].set_ylabel(features[indexesToPlot[i]])
         axes[i].grid()
+    axes[NumFeaturesToPlot-1].set_xlabel("Sample number")
     plt.show()
 
 
 def anomalyMetric(testList):  # first of list is non failure data
     # FP, TP: false/true positive
     # TN, FN: true/false negative
-    # Sensitivity: probab failure detection if data is fail: TP/(TP+FN)
+    # 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)  
+    # F-score: predictive performance measure: 2*Precision*Sensitity/(Precision+Sensitity)
 
     x_test = create_sequences(testList[0])
     x_test_pred = model.predict(x_test)
@@ -298,6 +306,8 @@ def anomalyMetric(testList):  # first of list is non failure data
     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])
         x_test_pred = model.predict(x_test)
@@ -309,13 +319,50 @@ def anomalyMetric(testList):  # first of list is non failure data
                 count+=1
         TP[i-1] = count
         FN[i-1] = anomalies.shape[0]-count
-    Sensitivity=TP.sum()/(TP.sum()+FN.sum())
-    Specifity=TN/(TN+FP)
+        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)
+    FScore= 2*GlobalPrecision*GlobalSensitivity/(GlobalPrecision+GlobalSensitivity)
+
     print("Sensitivity: ",Sensitivity)
-    print("Specifity: ",Specifity)
+    print("Global Sensitivity: ",GlobalSensitivity)
+    print("Precision: ",Precision)
+    print("Global Precision: ",GlobalPrecision)
+    print("Specifity: ",Specificity)
+    print("Accuracy: ",Accuracy)
+    print("FScore: ",FScore)
     print("FP: ",FP)
-    return Sensitivity+Specifity
+    #return Sensitivity+Specifity
+    return FScore
 
 anomalyMetric([dataTestNorm[0],dataTestNorm[1],dataTestNorm[2],dataTestNorm[3],dataTestNorm[4]])
-plotData2()
+
+
+def plotFScore():
+    global threshold
+    res=[]
+    # plots FSCroe as a function of Threshold  Factor
+    tf=0.3
+    while tf<1.5:
+        threshold=thresholdOrig*tf
+        r=anomalyMetric([dataTestNorm[0],dataTestNorm[1],dataTestNorm[2],dataTestNorm[3],dataTestNorm[4]])
+        res.append([tf,r])
+        tf+=0.05
+
+    print(res)
+    ar=np.array((res))
+    plt.rcParams.update({'font.size': 16})
+    fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(14, 10), dpi=80, facecolor="w", edgecolor="k")
+    axes.plot(ar[:,0],ar[:,1],label="normal train",linewidth=4)
+    axes.set_xlabel("Threshold factor")
+    axes.set_ylabel("F-Score")
+    plt.grid()
+    plt.show()
+
+#plotFScore()
+plotData3()