init

app.py

@@ -1,50 +1,142 @@
+# from tensorflow.keras.models import load_model
+# from tensorflow.keras.initializers import Orthogonal
+# from tensorflow.keras.utils import custom_object_scope
+# from tensorflow.keras.layers import LSTM
+# import gradio as gr
+# import pandas as pd
+# import numpy as np
+# # Initialize LSTM layer correctly without time_major
+# lstm_layer = LSTM(64, return_sequences=True)
+
+# # Register custom initializers or objects when loading the model
+# with custom_object_scope({'Orthogonal': Orthogonal}):
+#     model = load_model('models/lstm-combinedmodel.h5')
+
+# def predict_from_csv(file_path):
+#     # Load the data from CSV
+#     data = pd.read_csv(file_path)
+    
+#     # Reorder and preprocess data if necessary
+#     required_columns = ['CAN ID', 'RTR', 'DLC', 'Data1', 'Data2', 'Data3', 'Data4', 'Data5', 'Data6', 'Data7', 'Data8']
+#     data = data[required_columns]
+    
+#     # Convert data to numpy array or the format your model expects
+#     input_data = data.values
+    
+#     # Predict using the model
+#     predictions = model.predict(input_data)
+    
+#       # Determine the predicted class and confidence
+#     predicted_class = np.argmax(predictions, axis=1)[0]
+#     confidence = np.max(predictions, axis=1)[0]
+
+#     # Map numeric class to label
+#     class_labels = {0: "Normal", 1: "Anomaly"}
+#     label = class_labels[predicted_class]
+#     output = f"Predicted Class: {label}, Confidence: {confidence:.4f}"
+    
+#     return output
+
+# def interface_func(uploaded_file):
+#     # Use the prediction function on the uploaded file path
+#     predictions = predict_from_csv(uploaded_file.name)
+#     return predictions
+
+# iface = gr.Interface(fn=interface_func,
+#                      inputs=gr.File(label="Upload CSV"),
+#                      outputs="text",
+#                      description="Upload a CSV file with the specified columns to predict.")
+
+# iface.launch()
+
+
+import pandas as pd
+import gradio as gr
+import numpy as np
 from tensorflow.keras.models import load_model
 from tensorflow.keras.initializers import Orthogonal
 from tensorflow.keras.utils import custom_object_scope
 from tensorflow.keras.layers import LSTM
-import gradio as gr
-import pandas as pd
-import numpy as np
-# Initialize LSTM layer correctly without time_major
-lstm_layer = LSTM(64, return_sequences=True)
 
-# Register custom initializers or objects when loading the model
+
+# Initialize and load the model
 with custom_object_scope({'Orthogonal': Orthogonal}):
     model = load_model('models/lstm-combinedmodel.h5')
 
-def predict_from_csv(file_path):
-    # Load the data from CSV
-    data = pd.read_csv(file_path)
+
+# Function to parse text file into a DataFrame
+def parse_text_file(file):
+    # Dictionary to hold data extracted from the text file
+    dfdict = {}
+
+    # Read file lines and process them
+    for line in file.readlines():
+        line = line.split()  # Split line into parts
+        if 'Timestamp:' in line:
+            line.remove('Timestamp:')  # Remove specific label
+        if 'ID:' in line:
+            line.remove('ID:')
+        if 'DLC:' in line:
+            line.remove('DLC:')
+        
+        # Extract timestamp as key and remaining data as value
+        if line:
+            key = float(line[0])
+            value = line[1:]
+            dfdict[key] = value  # Add to dictionary
     
-    # Reorder and preprocess data if necessary
+    # Convert dictionary to DataFrame
+    df = pd.DataFrame.from_dict(dfdict, orient='index', columns=['CAN ID', 'RTR', 'DLC', 'Data1', 'Data2', 'Data3', 'Data4', 'Data5', 'Data6', 'Data7', 'Data8'])
+    df.index.name = 'Timestamp'  # Set index name
+    return df
+
+
+# Function to make predictions using the model
+def make_predictions(dataframe):
+    # Ensure DataFrame has the necessary columns
     required_columns = ['CAN ID', 'RTR', 'DLC', 'Data1', 'Data2', 'Data3', 'Data4', 'Data5', 'Data6', 'Data7', 'Data8']
-    data = data[required_columns]
     
-    # Convert data to numpy array or the format your model expects
-    input_data = data.values
+    if not all(col in dataframe.columns for col in required_columns):
+        raise ValueError("Missing required columns in the DataFrame.")
+    
+    # Convert to the format expected by the model
+    input_data = dataframe[required_columns].values
     
     # Predict using the model
     predictions = model.predict(input_data)
     
-      # Determine the predicted class and confidence
-    predicted_class = np.argmax(predictions, axis=1)[0]
-    confidence = np.max(predictions, axis=1)[0]
-
+    # Determine the predicted class and confidence
+    predicted_class = np.argmax(predictions, axis=1)
+    confidence = np.max(predictions, axis=1)
+    
     # Map numeric class to label
     class_labels = {0: "Normal", 1: "Anomaly"}
-    label = class_labels[predicted_class]
-    output = f"Predicted Class: {label}, Confidence: {confidence:.4f}"
     
-    return output
+    results = []
+    for cls, conf in zip(predicted_class, confidence):
+        results.append(f"Predicted Class: {class_labels[cls]}, Confidence: {conf:.4f}")
+    
+    return results
 
+
+# Gradio interface function
 def interface_func(uploaded_file):
-    # Use the prediction function on the uploaded file path
-    predictions = predict_from_csv(uploaded_file.name)
-    return predictions
+    # Parse the text file into a DataFrame
+    df = parse_text_file(uploaded_file)
+    
+    # Get predictions
+    predictions = make_predictions(df)
+    
+    return "\n".join(predictions)  # Return predictions as text
+
 
-iface = gr.Interface(fn=interface_func,
-                     inputs=gr.File(label="Upload CSV"),
-                     outputs="text",
-                     description="Upload a CSV file with the specified columns to predict.")
+# Set up the Gradio interface
+iface = gr.Interface(
+    fn=interface_func,
+    inputs=gr.File(label="Upload a text file"),
+    outputs="text",
+    description="Upload a text file with CAN data to receive predictions."
+)
 
+# Launch the interface
 iface.launch()