.

v5_class.py

 parser.add_option("-t", "--train", dest="train", help="Trains the models (false)", default=False, action="store_true")
 parser.add_option("-n", "--timesteps", dest="timesteps", help="TIME STEPS ", default=12)
 parser.add_option("-r", "--transition", dest="transition", help="Includes transition data (false)", default=False, action="store_true")
+parser.add_option("-p", "--plot", dest="plot", help="Only plot data (false)", default=False, action="store_true")
 #parser.add_option("-f", "--thresholdfactor", dest="TF", help="Threshold Factor ", default=1.4)
 # threshold makes no sense when classifying, becaues we apply many models and decide class for the less MSE
 
 datafiles[0][1]=['2024-12-11_5_', '2024-12-12_5_','2024-12-13_5_'] 
 datafiles[0][2]=['2024-12-18_5_','2024-12-21_5_','2024-12-22_5_','2024-12-23_5_','2024-12-24_5_'] 
 datafiles[0][3]=['2024-12-28_5_','2024-12-29_5_','2024-12-30_5_'] 
+#datafiles[0][4]=['2025-02-05_5_','2025-02-10_5_']
 
 if options.transition:
     datafiles[1][0]=['2025-01-27_5_','2025-01-28_5_'] 
     datafiles[1][1]=['2024-12-14_5_','2024-12-15_5_','2024-12-16_5_']  # with TRANSITION
     datafiles[1][2]=['2024-12-17_5_','2024-12-19_5_','2024-12-25_5_','2024-12-26_5_'] # with TRANSITION
     datafiles[1][3]=['2024-12-27_5_','2024-12-31_5_','2025-01-01_5_'] # with TRANSITION
+    #datafiles[1][4]=['2025-02-05_5_','2025-02-10_5_']
+
 else:
     datafiles[1][0]=['2025-01-27_5_','2025-01-28_5_'] 
     datafiles[1][1]=['2024-12-14_5_','2024-12-15_5_'] 
     datafiles[1][2]=['2024-12-19_5_','2024-12-25_5_','2024-12-26_5_'] 
     datafiles[1][3]=['2024-12-31_5_','2025-01-01_5_'] 
+    #datafiles[1][4]=['2025-02-05_5_','2025-02-10_5_']
  
 
 #datafiles[0][4]=['2025-02-05_5_'] 
     (dataTrainNorm[i],dataTestNorm[i])=normalize2(dataTrain[i],dataTest[i])
 
 
+
 NumFilters=64
 KernelSize=7
 DropOut=0.2
     indexesToPlot.append(features.index(i))
 
 
+def plotData():
+    NumFeaturesToPlot=len(indexesToPlot)
+    plt.rcParams.update({'font.size': 16})
+    fig, axes = plt.subplots(
+        nrows=NumFeaturesToPlot, ncols=1, figsize=(15, 10), dpi=80, facecolor="w", edgecolor="k",sharex=True
+    )
+    for i in range(NumFeaturesToPlot):
+        init=0
+        end=testRanges[0][1]
+        for j in range(NumberOfFailures+1):
+            if NumFeaturesToPlot==1:
+                axes.plot(range(init,end),x_test[testRanges[j][0]:testRanges[j][1],0,indexesToPlot[i]]*stdevs[i]+means[i],label="Class "+str(j), color=colorline[j],linewidth=1)
+            else:
+                axes[i].plot(range(init,end),x_test[testRanges[j][0]:testRanges[j][1],0,indexesToPlot[i]]*stdevs[i]+means[i],label="Class "+str(j), color=colorline[j],linewidth=1)
+            if j<NumberOfFailures:
+                init=end
+                end+=(testRanges[j+1][1]-testRanges[j+1][0])
+
+
+        s=''
+        s+=featureNames[features[indexesToPlot[i]]]
+        s+=' '+unitNames[features[indexesToPlot[i]]]
+        if NumFeaturesToPlot==1:
+            axes.set_ylabel(s)
+            axes.grid()
+        else:
+            axes[i].set_ylabel(s)
+            axes[i].grid()
+            
+    if NumFeaturesToPlot==1:
+        axes.legend(ncol=4,loc=(0.1,0.98))
+    else:
+        axes[0].legend(ncol=4,loc=(0.1,0.98))
+    plt.show()
+
 
 #   2nd scenario. Go over anomalies and classify it by less error
 datalist=[dataTestNorm[0],dataTestNorm[1],dataTestNorm[2],dataTestNorm[3]]
+#datalist=[dataTestNorm[0],dataTestNorm[1],dataTestNorm[2],dataTestNorm[3],dataTestNorm[4]]
 x_test=create_sequences(datalist[0],int(options.timesteps))
 for i in range(1,len(datalist)):
     x_test=np.vstack((x_test,create_sequences(datalist[i],int(options.timesteps))))
     testRanges.append([r,r+datalist[i].shape[0]-int(options.timesteps)+1])
     r+=datalist[i].shape[0]-int(options.timesteps)+1
 
+if options.plot:
+# Only plot data and exit
+    plotData()
+    exit(0)
+
 testClasses=[0,1,2,3]
 
 if not len(testClasses)==len(testRanges):
 anomalyMetric(classes,testRanges,testClasses)
 plotData4()
 
+# Compute delay until correct detection for a list of ranges (when transition data exists)
+def computeDelay(l,classes,testRanges,testClasses):
+    d=np.zeros(len(l))
+    NoFailsInARow=4
+    ind=0
+    for i in l:
+        start=testRanges[i][0]
+        count=0
+        while start<testRanges[i][1]:
+            start+=1
+            if classes[start]==testClasses[i]:
+                count+=1
+            if count==NoFailsInARow:
+                count=0
+                #print(start,start-testRanges[i][0]-NoFailsInARow+timesteps)
+                d[ind]=start-testRanges[i][0]-NoFailsInARow+timesteps
+                break
+        ind+=1
+    return(d.mean())
+
+d=computeDelay([2,3],classes,testRanges,testClasses)
+print("mean delay: ",d)
+