.

plotFscore_v4.py

+import matplotlib.pyplot as plt
+import numpy as np
+import pickle
+
+listOfFeatures=[['r1 s1'], ['r1 s4'], ['r1 s5'], ['r1 s1','r1 s4'], ['r1 s1','r1 s5'], ['r1 s4','r1 s5'], ['r1 s1','r1 s4','r1 s5'] ]
+featureNames={}
+featureNames['r1 s1']='$T_{evap}$'
+featureNames['r1 s4']='$T_{cond}$'
+featureNames['r1 s5']='$T_{air}$'
+featureNames['pa1 apiii']='$P_{elec}$'
+
+
+def listToString(l):
+    r=''
+    for i in l:
+        r+=str(i)
+    return(r.replace(' ',''))
+
+FS=[]
+for l in listOfFeatures:
+    print(l)
+    file = open('FScore_v4_'+listToString(l)+'.pk', 'rb')
+    FS.append(pickle.load(file))
+    file.close()
+
+plt.rcParams.update({'font.size': 16})
+fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(14, 10), dpi=80, facecolor="w", edgecolor="k",sharex=True)
+tsToPlot=[4,8,12,16]
+for row in range(2):
+    for col in range(2):
+        ind=row*2+col
+        for k in range(len(FS)):
+            ar=np.array((FS[k][tsToPlot[ind]]))
+
+            s='['
+            for i in range(len(listOfFeatures[k])):
+                s+=featureNames[listOfFeatures[k][i]]
+                if i < len(listOfFeatures[k])-1:
+                    s+=', '
+            s+=']'
+
+
+            axes[row][col].plot(ar[:,0],ar[:,1],label=s,linewidth=3)
+#axes.set_xlabel("Threshold factor")
+        if col==0:
+            axes[row][col].set_ylabel("F1-Score")
+        if row==1:
+            axes[row][col].set_xlabel("Threshold Factor ($tf$)")
+        axes[row][col].grid()
+        axes[row][col].set_title('$ns=$'+str(tsToPlot[ind]))
+axes[0][0].legend(loc='lower right')
+#plt.title(str(features))
+plt.show()
+
+
+

v4.py

 # because dataTrain is not stacke before create_sequences,  so, 
 #  the sets are not aligned in time
 
-# Optimizxation of threshold factor changed, bacause is based on F1-Score  AKI
+# Because in this case we don't observe into transitories, we keep independently each train set
+
+# Optimizxation of threshold factor changed, bacause is based on F1-Score
 
 import pandas as pd
 import matplotlib.pyplot as plt
 
 features=['r1 s1','r1 s4','r1 s5','pa1 apiii']
 features=['r1 s1','r1 s4','r1 s5']
+features=['r1 s1','r1 s5']
 featureNames={}
 featureNames['r1 s1']='$T_{evap}$'
 featureNames['r1 s4']='$T_{cond}$'
     # 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)
         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("Sensitivity: ",Sensitivity)
+    print("Global Precision: ",GlobalPrecision)
+    print("Precision: ",Precision)
     print("Global Sensitivity: ",GlobalSensitivity)
-    #print("Precision: ",Precision)
-    #print("Global Precision: ",GlobalPrecision)
-    print("Specifity: ",Specificity)
+    print("Sensitivity: ",Sensitivity)
+    #print("Specifity: ",Specificity)
     #print("Accuracy: ",Accuracy)
-    #print("F1Score: ",F1Score)
-    print("F2Score: ",F2Score)
+    print("F1Score: ",F1Score)
+    #print("F2Score: ",F2Score)
     #print("FP: ",FP)
     #return Sensitivity+Specifity
-    return F2Score
+    return F1Score
 
 FScoreHash={}
 threshold={}
 def getFScore(timestep,datalist):
     FScoreHash[timestep]=[]
-    # plots FSCore as a function of Threshold  Factor
     tf=0.3
     while tf<8:
         th=threshold[timestep]*tf
         ar=np.array((FS[k]))
         axes.plot(ar[:,0],ar[:,1],label="$ns=$"+str(k),linewidth=3)
     axes.set_xlabel("Threshold factor ($tf$)")
-    axes.set_ylabel("FScore")
+    axes.set_ylabel("F1-Score")
     axes.legend()
     axes.grid()
     s='['
         )
         model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss="mse")
         model.summary()
-        path_checkpoint="model_noclass_v2_"+str(timesteps)+listToString(features)+"_checkpoint.weights.h5"
+        path_checkpoint="model_noclass_v4_"+str(timesteps)+listToString(features)+"_checkpoint.weights.h5"
         es_callback=keras.callbacks.EarlyStopping(monitor="val_loss", min_delta=0, patience=15)
         modelckpt_callback=keras.callbacks.ModelCheckpoint( monitor="val_loss", filepath=path_checkpoint, verbose=1, save_weights_only=True, save_best_only=True,)
 
         x_train_pred=model.predict(x_train[0])
         train_mae_loss=np.mean(np.abs(x_train_pred - x_train[0]), axis=1)
         threshold[timesteps]=np.max(train_mae_loss,axis=0)
-    file = open('threshold'+listToString(features)+'.pk', 'wb')
+    file = open('threshold_v4_'+listToString(features)+'.pk', 'wb')
     pickle.dump(threshold, file)
     file.close()
     exit(0)
 else:
-    file = open('threshold'+listToString(features)+'.pk', 'rb')
+    file = open('threshold_v4_'+listToString(features)+'.pk', 'rb')
     threshold=pickle.load(file)
     file.close()
 
     
     if options.optimizetf:
         for timesteps in range(4,21,4):
-            path_checkpoint="model_noclass_v2_"+str(timesteps)+listToString(features)+"_checkpoint.weights.h5"
+            path_checkpoint="model_noclass_v4_"+str(timesteps)+listToString(features)+"_checkpoint.weights.h5"
             es_callback=keras.callbacks.EarlyStopping(monitor="val_loss", min_delta=0, patience=15)
             modelckpt_callback=keras.callbacks.ModelCheckpoint( monitor="val_loss", filepath=path_checkpoint, verbose=1, save_weights_only=True, save_best_only=True,)
             model.load_weights(path_checkpoint)
             getFScore(timesteps,[dataTestNorm[0],dataTrainNorm[1],dataTrainNorm[2],dataTrainNorm[3],dataTrainNorm[4]])
-        file = open('FScore'+listToString(features)+'.pk', 'wb')
+        file = open('FScore_v4_'+listToString(features)+'.pk', 'wb')
         pickle.dump(FScoreHash, file)
         file.close()
 
 
-    path_checkpoint="model_noclass_v2_"+str(options.timesteps)+listToString(features)+"_checkpoint.weights.h5"
+    path_checkpoint="model_noclass_v4_"+str(options.timesteps)+listToString(features)+"_checkpoint.weights.h5"
     es_callback=keras.callbacks.EarlyStopping(monitor="val_loss", min_delta=0, patience=15)
     modelckpt_callback=keras.callbacks.ModelCheckpoint( monitor="val_loss", filepath=path_checkpoint, verbose=1, save_weights_only=True, save_best_only=True,)
     model.load_weights(path_checkpoint)
 
 
-    file = open('FScore'+listToString(features)+'.pk', 'rb')
+    file = open('FScore_v4_'+listToString(features)+'.pk', 'rb')
     FS=pickle.load(file)
     file.close()
 
 # For Failure data, we can use Train data becasue not used for training and includes the firsts samples
 #datalist=[dataTestNorm[0],dataTrainNorm[1],dataTrainNorm[2],dataTrainNorm[3],dataTrainNorm[4]]
 datalist=[dataTestNorm[0],dataTestNorm[1],dataTestNorm[2],dataTestNorm[3],dataTestNorm[4]]
-d=np.vstack((datalist))
 
-x_test = create_sequences(d,int(options.timesteps))
+
+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))))
 x_test_pred = model.predict(x_test)
 test_mae_loss = np.mean(np.abs(x_test_pred - x_test), axis=1)
 
 
 # Define ranges for plotting in different colors
 testRanges=[]
-
 r=0
 for i in range(len(datalist)):
-    testRanges.append([r,r+datalist[i].shape[0]])
-    r+=datalist[i].shape[0]
+    testRanges.append([r,r+datalist[i].shape[0]-int(options.timesteps)])
+    r+=datalist[i].shape[0]-int(options.timesteps)
 
 #r=dataTestNorm[0].shape[0]
 #testRanges.append([0,r])
 #    testRanges.append([r,rnext] )
 #    r=rnext
 
-# Drop the last TIME_STEPS for plotting
-testRanges[NumberOfFailures][1]=testRanges[NumberOfFailures][1]-TIME_STEPS
 
 
 anomalies = test_mae_loss > threshold[int(options.timesteps)]*float(options.TF)
         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]]*stdevs[i]+means[i])
+            if (k)<x_test.shape[0]:
+                x.append(k)
+                y.append(x_test[k,0,indexesToPlot[i]]*stdevs[i]+means[i])
         axes[i].plot(x,y ,color='black',marker='.',linewidth=0,label="Fail detection" )
 
-
         init=0
         end=testRanges[0][1]
         axes[i].plot(range(init,end),x_test[testRanges[0][0]:testRanges[0][1],0,indexesToPlot[i]]*stdevs[i]+means[i],label="No fail")
                 init=end
                 end+=(testRanges[j+1][1]-testRanges[j+1][0])
 
-
         if i==(NumFeatures-1):
             axes[i].legend(loc='right')
         s=''
 plotData3()
 
 
-def plotData5():
-    model1 = keras.Sequential(
-        [
-            layers.Input(shape=(4, 3)),
-            layers.Conv1D(
-                filters=NumFilters,
-                kernel_size=KernelSize,
-                padding="same",
-                strides=2,
-                activation="relu",
-            ),
-            layers.Dropout(rate=DropOut),
-            layers.Conv1D(
-                filters=int(NumFilters/2),
-                kernel_size=KernelSize,
-                padding="same",
-                strides=2,
-                activation="relu",
-            ),
-            layers.Conv1DTranspose(
-                filters=int(NumFilters/2),
-                kernel_size=KernelSize,
-                padding="same",
-                strides=2,
-                activation="relu",
-            ),
-            layers.Dropout(rate=DropOut),
-            layers.Conv1DTranspose(
-                filters=NumFilters,
-                kernel_size=KernelSize,
-                padding="same",
-                strides=2,
-                activation="relu",
-            ),
-            layers.Conv1DTranspose(filters=3, kernel_size=KernelSize, padding="same"),
-        ]
-    )
-    model1.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss="mse")
-    model1.summary()
-    path_checkpoint="model_noclass_v2_"+str(4)+listToString(features)+"_checkpoint.weights.h5"
-    es_callback=keras.callbacks.EarlyStopping(monitor="val_loss", min_delta=0, patience=15)
-    modelckpt_callback=keras.callbacks.ModelCheckpoint( monitor="val_loss", filepath=path_checkpoint, verbose=1, save_weights_only=True, save_best_only=True,)
-    model1.load_weights(path_checkpoint)
-
-    model2 = keras.Sequential(
-        [
-            layers.Input(shape=(20, 3)),
-            layers.Conv1D(
-                filters=NumFilters,
-                kernel_size=KernelSize,
-                padding="same",
-                strides=2,
-                activation="relu",
-            ),
-            layers.Dropout(rate=DropOut),
-            layers.Conv1D(
-                filters=int(NumFilters/2),
-                kernel_size=KernelSize,
-                padding="same",
-                strides=2,
-                activation="relu",
-            ),
-            layers.Conv1DTranspose(
-                filters=int(NumFilters/2),
-                kernel_size=KernelSize,
-                padding="same",
-                strides=2,
-                activation="relu",
-            ),
-            layers.Dropout(rate=DropOut),
-            layers.Conv1DTranspose(
-                filters=NumFilters,
-                kernel_size=KernelSize,
-                padding="same",
-                strides=2,
-                activation="relu",
-            ),
-            layers.Conv1DTranspose(filters=3, kernel_size=KernelSize, padding="same"),
-        ]
-    )
-    model2.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss="mse")
-    model2.summary()
-    path_checkpoint="model_noclass_v2_"+str(20)+listToString(features)+"_checkpoint.weights.h5"
-    es_callback=keras.callbacks.EarlyStopping(monitor="val_loss", min_delta=0, patience=15)
-    modelckpt_callback=keras.callbacks.ModelCheckpoint( monitor="val_loss", filepath=path_checkpoint, verbose=1, save_weights_only=True, save_best_only=True,)
-    model2.load_weights(path_checkpoint)
-
-    datalist=[dataTestNorm[0],dataTestNorm[3],dataTestNorm[2],dataTestNorm[1],dataTestNorm[4]]
-    d=np.vstack((datalist))
-    x_test = create_sequences(d,4)
-    x_test_pred = model1.predict(x_test)
-    test_mae_loss = np.mean(np.abs(x_test_pred - x_test), axis=1)
-    testRanges=[]
-    TIME_STEPS=4
-    r=0
-    for i in range(len(datalist)):
-        testRanges.append([r,r+datalist[i].shape[0]])
-        r+=datalist[i].shape[0]
-    testRanges[NumberOfFailures][1]=testRanges[NumberOfFailures][1]-TIME_STEPS
-    anomalies = test_mae_loss > threshold[4]*float(options.TF)
-    anomalous_data_indices = []
-    for i in range(anomalies.shape[0]):
-        if AtLeastOneTrue(anomalies[i]):
-            anomalous_data_indices.append(i)
-
-    plt.rcParams.update({'font.size': 16})
-    fig, axes = plt.subplots(
-        nrows=2, ncols=1, figsize=(15, 7), dpi=80, facecolor="w", edgecolor="k" , sharex=True
- )
-    for i in range(1):
-        init=0
-        end=testRanges[0][1]
-        axes[i].plot(range(init,end),x_test[testRanges[0][0]:testRanges[0][1],0,indexesToPlot[i]]*stdevs[i]+means[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]]*stdevs[i]+means[i],label="Fail type "+str(j), color=colorline[j-1])
-            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]]*stdevs[i]+means[i])
-        axes[i].plot(x,y ,color='black',marker='.',linewidth=0,label="Fail detection" )
-
-        if i==(NumFeatures-1):
-            axes[i].legend(loc='right')
-        s=''
-        s+=featureNames[features[indexesToPlot[i]]]
-        s+=' '+unitNames[features[indexesToPlot[i]]]
-        axes[i].set_ylabel(s)
-        axes[i].grid()
-
-
-    x_test = create_sequences(d,20)
-    x_test_pred = model2.predict(x_test)
-    test_mae_loss = np.mean(np.abs(x_test_pred - x_test), axis=1)
-    testRanges=[]
-    r=0
-    TIME_STEPS=20
-    for i in range(len(datalist)):
-        testRanges.append([r,r+datalist[i].shape[0]])
-        r+=datalist[i].shape[0]
-    testRanges[NumberOfFailures][1]=testRanges[NumberOfFailures][1]-TIME_STEPS
-    anomalies = test_mae_loss > threshold[20]*float(options.TF)
-    anomalous_data_indices = []
-    for i in range(anomalies.shape[0]):
-        if AtLeastOneTrue(anomalies[i]):
-            anomalous_data_indices.append(i)
-    print(testRanges)
-    for i in range(1):
-        init=0
-        end=testRanges[0][1]
-        axes[i+1].plot(range(init,end),x_test[testRanges[0][0]:testRanges[0][1],0,indexesToPlot[i]]*stdevs[i]+means[i],label="No fail")
-        init=end
-        end+=(testRanges[1][1]-testRanges[1][0])
-        for j in range(1,NumberOfFailures+1):
-            if j==1:
-                axes[i+1].plot(range(init,end),x_test[testRanges[j][0]:testRanges[j][1],0,indexesToPlot[i]]*stdevs[i]+means[i],label="Fail type 3", color=colorline[j-1])
-            else:
-                axes[i+1].plot(range(init,end),x_test[testRanges[j][0]:testRanges[j][1],0,indexesToPlot[i]]*stdevs[i]+means[i], color=colorline[j-1])
-            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]]*stdevs[i]+means[i])
-        axes[i+1].plot(x,y ,color='black',marker='.',linewidth=0,label="Fail detection" )
-        if i==0:
-            axes[i+1].legend(loc='right')
-        s=''
-        s+=featureNames[features[indexesToPlot[i]]]
-        s+=' '+unitNames[features[indexesToPlot[i]]]
-        axes[i+1].set_ylabel(s)
-        axes[i+1].grid()
-    
-    axes[0].set_xlim(460,480)
-    axes[1].set_xlim(460,480)
-
-    axes[0].set_title('$ns=4$')
-    axes[1].set_title('$ns=20$')
-    axes[1].set_xlabel("Sample number")
-    plt.show()
-
-
-
-plotData5()
 exit(0)