# -*- coding: utf-8 -*-

"""ML_Project.ipynb

Automatically generated by Colab.

Original file is located at

    https://colab.research.google.com/drive/1N-OfEL_dUBWC58ZTYK4NUEUkakSCj2rS

"""

import pandas as pd

# Load the data from the CSV file

data = pd.read_csv('/content/Dataaa.csv')

# Display the number of features

print("Number of features in the dataset:", data.shape[1])

print("Names of the features:", data.columns.tolist())

# Display the first few lines of the CSV file to understand its content

with open('/content/Dataaa.csv', 'r') as file:

    for _ in range(5):

        print(file.readline())

import numpy as np

import pandas as pd

# Assuming you have your data loaded into numpy arrays, for example:

# X_in is your input data and X_out is your output data

# Here is a simple example of how to create these arrays (replace this with your actual data loading code)

# X_in = np.random.rand(100, 10)  # Example: 100 samples, 10 features

# X_out = np.random.rand(100, 3)  # Example: 100 samples, 3 output targets

# Convert numpy arrays to pandas DataFrame

X_in_df = pd.DataFrame(X_in)

X_out_df = pd.DataFrame(X_out)

# Concatenate both DataFrames along the columns

data_df = pd.concat([X_in_df, X_out_df], axis=1)

# Save the DataFrame to a CSV file

data_df.to_csv('/content/corrected_data.csv', index=False)

import numpy as np

import pandas as pd

# Example data (replace with your actual data arrays)

X_in = np.random.rand(100, 10)  # 100 samples, 10 features

X_out = np.random.rand(100, 1)  # 100 samples, 1 target

# Convert to DataFrame

df_in = pd.DataFrame(X_in, columns=[f'feature_{i}' for i in range(X_in.shape[1])])

df_out = pd.DataFrame(X_out, columns=['target'])

# Combine input and output data

full_df = pd.concat([df_in, df_out], axis=1)

# Save to CSV

full_df.to_csv('/content/corrected_data.csv', index=False)

import pandas as pd

# Load the data from the corrected CSV file

data = pd.read_csv('/content/corrected_data.csv')

# Display the first few rows of the dataset and the shape to verify

print(data.head())

print("Shape of the dataset:", data.shape)

print("Column names:", data.columns.tolist())

##Normalizing and Splitting the data

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

# Selecting input features and target

X = data.iloc[:, :-1].values  # All columns except the last are features

y = data.iloc[:, -1].values  # Last column is the target

# Normalize the input data

scaler = StandardScaler()

X_normalized = scaler.fit_transform(X)

# Split the data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X_normalized, y, test_size=0.3, random_state=42)

# Output the shapes of the datasets to verify everything is as expected

print("Train data shape:", X_train.shape)

print("Test data shape:", X_test.shape)

##Training the RNN Model

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, SimpleRNN

# Define the RNN model

model = Sequential([

    SimpleRNN(50, input_shape=(X_train.shape[1], 1)),  # 50 RNN units, considering each feature as a time step

    Dense(1)  # Output layer with one neuron for regression output (the target)

])

# Compile the model

model.compile(optimizer='adam', loss='mean_squared_error')

# Reshape input for RNN which expects (batch_size, timesteps, features)

X_train_rnn = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))

X_test_rnn = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))

# Train the model

history = model.fit(X_train_rnn, y_train, epochs=100, validation_data=(X_test_rnn, y_test))

# Optionally, plot the training and validation loss

import matplotlib.pyplot as plt

plt.plot(history.history['loss'], label='train')

plt.plot(history.history['val_loss'], label='test')

plt.title('Model Loss')

plt.ylabel('Loss')

plt.xlabel('Epoch')

plt.legend()

plt.show()

model.save('/content/my_rnn_model.h5')  # Saves the model for later use

# Example threshold value - you need to choose what makes sense for your data

threshold = 0.5

# Convert continuous target data to binary classification

y_train_class = (y_train > threshold).astype(int)

# Proceed with the rest of your RNN setup as before

##Classifying the presence of damage

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import SimpleRNN, Dense

# Define the classification model

classification_model = Sequential([

    SimpleRNN(50, input_shape=(X_train.shape[1], 1)),  # Adjust the input shape and units as necessary

    Dense(1, activation='sigmoid')  # Sigmoid activation for binary classification

])

# Compile the classification model

classification_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Reshape data for RNN

X_train_rnn = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))

# Train the classification model

classification_model.fit(X_train_rnn, y_train_class, epochs=100, validation_split=0.2)

# Save the classification model

classification_model.save('/content/classification_model.h5')

# Assuming your original test labels are in y_test, and they are not binary (0 or 1) yet

# Apply the same threshold used for the training data

y_test_class = (y_test > threshold).astype(int)

# Now you can compute the confusion matrix and plot it

cm = confusion_matrix(y_test_class, y_pred_class)

disp = ConfusionMatrixDisplay(confusion_matrix=cm)

disp.plot(cmap=plt.cm.Blues)

plt.title('Confusion Matrix')

plt.show()

# And compute the ROC curve

fpr, tpr, _ = roc_curve(y_test_class, y_pred_probs.ravel())

roc_auc = auc(fpr, tpr)

# Plot the ROC curve

plt.figure()

plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)

plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')

plt.xlabel('False Positive Rate')

plt.ylabel('True Positive Rate')

plt.title('Receiver Operating Characteristic')

plt.legend(loc="lower right")

plt.show()

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import LSTM, Dense, Dropout

from sklearn.utils.class_weight import compute_class_weight

from sklearn.metrics import precision_recall_curve

# Calculate class weights

class_weights = compute_class_weight('balanced', classes=np.unique(y_train_class), y=y_train_class)

class_weights_dict = dict(enumerate(class_weights))

# Build an LSTM model

model = Sequential([

    LSTM(100, input_shape=(X_train.shape[1], 1), return_sequences=True),

    Dropout(0.5),

    LSTM(100),

    Dropout(0.5),

    Dense(1, activation='sigmoid')

])

# Compile the model

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the model with class weights

history = model.fit(X_train_rnn, y_train_class, epochs=100, validation_split=0.2, class_weight=class_weights_dict)

# Predict probabilities

y_pred_probs = model.predict(X_test_rnn)

# Find the optimal threshold based on precision-recall tradeoff

precision, recall, thresholds = precision_recall_curve(y_test_class, y_pred_probs)

# Convert to f score

fscore = (2 * precision * recall) / (precision + recall)

# Locate the index of the largest f score

ix = np.argmax(fscore)

optimal_threshold = thresholds[ix]

# Use the optimal threshold to convert probabilities to binary predictions

y_pred_class = (y_pred_probs > optimal_threshold).astype(int)

# Recompute the confusion matrix and ROC curve using the new threshold

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, roc_curve, auc

import matplotlib.pyplot as plt

# Use the optimal threshold to convert probabilities to binary predictions

y_pred_class_optimal = (y_pred_probs > optimal_threshold).astype(int)

# Compute the confusion matrix using the optimal threshold

cm_optimal = confusion_matrix(y_test_class, y_pred_class_optimal)

# Display the confusion matrix

disp = ConfusionMatrixDisplay(confusion_matrix=cm_optimal)

disp.plot(cmap=plt.cm.Blues)

plt.title('Confusion Matrix with Optimal Threshold')

plt.show()

# Compute ROC curve and AUC

fpr, tpr, _ = roc_curve(y_test_class, y_pred_probs)

roc_auc = auc(fpr, tpr)

# Plot ROC curve

plt.figure()

plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)

plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')

plt.xlabel('False Positive Rate')

plt.ylabel('True Positive Rate')

plt.title('Receiver Operating Characteristic with Optimal Threshold')

plt.legend(loc="lower right")

plt.show()

# Make sure the 'y_test_class' and 'y_train_class' variables are set correctly before this step.

# For the sake of example, let's assume 'y_test' is the variable holding the original test labels.

# Verify and correct labels if necessary

# 'damage' is 1, 'no damage' is 0

y_test_class = np.where(y_test == 'damage', 1, 0)

# Now, use your model to predict probabilities on the test set

# Assuming 'X_test_rnn' is already defined and shaped correctly

y_pred_probs = classification_model.predict(X_test_rnn)

# Choose a decision threshold (if you've found an optimal one, use that, otherwise use 0.5)

threshold = 0.5  # or optimal_threshold if you have one

# Convert predicted probabilities into binary class predictions

y_pred_class = (y_pred_probs > threshold).astype(int)

# Compute the confusion matrix

cm = confusion_matrix(y_test_class, y_pred_class)

# Plot the confusion matrix

disp = ConfusionMatrixDisplay(confusion_matrix=cm)

disp.plot(cmap=plt.cm.Blues)

plt.title('Confusion Matrix')

plt.show()

# Calculate the ROC curve and AUC

fpr, tpr, _ = roc_curve(y_test_class, y_pred_probs)

roc_auc = auc(fpr, tpr)

# Plot the ROC curve

plt.figure()

plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')

plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')

plt.xlabel('False Positive Rate')

plt.ylabel('True Positive Rate')

plt.title('Receiver Operating Characteristic')

plt.legend(loc='lower right')

plt.show()

# Reshape data from 2D to 3D (samples, timesteps, features)

X_train_rnn = X_train.reshape((X_train.shape[0], 1, X_train.shape[1]))

# Define the LSTM model for binary classification

lstm_model = Sequential([

    LSTM(50, input_shape=(X_train_rnn.shape[1], X_train_rnn.shape[2])),  # Correct input_shape

    Dense(1, activation='sigmoid')

])

# Compile the LSTM model

lstm_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the LSTM model

history = lstm_model.fit(X_train_rnn, y_train_class, epochs=100, validation_split=0.2)

# ... (Continue with the rest of the code as before)

# Assuming your data is correctly reshaped to 3D for LSTM and 'y_train_class' holds the binary labels

# Continue training the LSTM model

history = lstm_model.fit(

    X_train_rnn,

    y_train_class,

    epochs=100,

    validation_split=0.2

)

# Assuming 'X_test' and 'y_test' are your test data and labels, respectively

# Reshape the test data to match the input shape of the model

X_test_rnn = X_test.reshape((X_test.shape[0], 1, X_test.shape[1]))

# Predict class probabilities on the test set

y_pred_probs = lstm_model.predict(X_test_rnn)

# Choose a decision threshold

threshold = 0.5  # Adjust based on your optimal threshold

y_pred_class = (y_pred_probs > threshold).astype(int)

# Compute the confusion matrix

cm = confusion_matrix(y_test_class, y_pred_class)

# Display the confusion matrix

disp = ConfusionMatrixDisplay(confusion_matrix=cm)

disp.plot(cmap=plt.cm.Blues)

plt.title('Confusion Matrix - LSTM Model')

plt.show()

# Compute ROC curve and AUC

fpr, tpr, _ = roc_curve(y_test_class, y_pred_probs)

roc_auc = auc(fpr, tpr)

# Plot ROC curve

plt.figure()

plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)

plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')

plt.xlabel('False Positive Rate')

plt.ylabel('True Positive Rate')

plt.title('ROC Curve - LSTM Model')

plt.legend(loc="lower right")

plt.show()

# Check the range of predicted probabilities

print("Predicted probabilities:", y_pred_probs)

# Check if there are both classes present in the test labels

print("Unique labels in y_test_class:", np.unique(y_test_class))

# Check unique values in the labels array

unique_classes = np.unique(y)

print("Unique classes in y:", unique_classes)

# Define a threshold to convert continuous values to binary classification

threshold = 0.5  # This is just an example, adjust this based on your domain knowledge

y_class = (y > threshold).astype(int)

# Now check the distribution of the new binary labels

print("Distribution of binary labels:", np.bincount(y_class))

# Continue with the train-test split with the new binary labels

X_train, X_test, y_train_class, y_test_class = train_test_split(

    X, y_class,

    test_size=0.2,

    stratify=y_class,

    random_state=42

)

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import confusion_matrix, roc_curve, auc, ConfusionMatrixDisplay

import matplotlib.pyplot as plt

# Perform the stratified train-test split with the new binary labels

X_train, X_test, y_train_class, y_test_class = train_test_split(

    X, y_class,

    test_size=0.2,

    stratify=y_class,

    random_state=42

)

# Train the logistic regression model

logistic_model = LogisticRegression()

logistic_model.fit(X_train, y_train_class)

# Predict class probabilities on the test set

y_pred_probs_logistic = logistic_model.predict_proba(X_test)[:, 1]

# Predict class labels for the test set based on the default threshold of 0.5

y_pred_class_logistic = logistic_model.predict(X_test)

# Compute the confusion matrix

cm_logistic = confusion_matrix(y_test_class, y_pred_class_logistic)

# Display the confusion matrix

disp = ConfusionMatrixDisplay(confusion_matrix=cm_logistic)

disp.plot(cmap=plt.cm.Blues)

plt.title('Confusion Matrix - Logistic Regression Model')

plt.show()

# Compute ROC curve and AUC

fpr_logistic, tpr_logistic, _ = roc_curve(y_test_class, y_pred_probs_logistic)

roc_auc_logistic = auc(fpr_logistic, tpr_logistic)

# Plot the ROC curve

plt.figure()

plt.plot(fpr_logistic, tpr_logistic, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc_logistic)

plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')

plt.xlabel('False Positive Rate')

plt.ylabel('True Positive Rate')

plt.title('ROC Curve - Logistic Regression Model')

plt.legend(loc="lower right")

plt.show()

# Reshape X_test_rnn to match the expected input shape of the model (10 time steps, 1 feature per step)

X_test_rnn_reshaped = X_test_rnn.reshape((X_test_rnn.shape[0], 10, 1))

# Now make predictions with the reshaped data

y_pred_probs_rnn = rnn_model.predict(X_test_rnn_reshaped)

# Continue with the rest of the code for evaluation

print("Number of samples in test set:", y_test_class.shape[0])

print("Number of predictions made:", y_pred_probs_rnn.shape[0])

##Using LSTM to better predict

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import LSTM, Dense

# Define the LSTM model for binary classification

lstm_classification_model = Sequential([

    LSTM(2, input_shape=(X_train.shape[1], 1)),  # 50 LSTM units

    Dense(1, activation='sigmoid')  # Sigmoid activation for binary classification

])

# Compile the LSTM model

lstm_classification_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the LSTM model

history = lstm_classification_model.fit(

    X_train_rnn, y_train_class,

    epochs=100,

    validation_split=0.2

)

# Save the LSTM classification model

lstm_classification_model.save('/content/lstm_classification_model.h5')

#Model Evaluation

# Evaluate the model's performance

test_loss, test_accuracy = lstm_classification_model.evaluate(X_test_rnn, y_test_binary)

# Print the evaluation results

print(f"Test Loss: {test_loss}")

print(f"Test Accuracy: {test_accuracy}")

#Regularizing to make LSTM better

from sklearn.utils.class_weight import compute_class_weight

# Calculate class weights for unbalanced datasets

class_weights = compute_class_weight(

    class_weight='balanced',

    classes=np.unique(y_train_class),

    y=y_train_class

)

# Create a dictionary mapping class labels to weights

weight_for_class_1 = class_weights[1]

class_weight_dict = {0: class_weights[0], 1: class_weights[1]}

# Train the model with class weight to handle imbalance

history = lstm_classification_model.fit(

    X_train_rnn, y_train_class,

    epochs=100,

    validation_split=0.2,

    class_weight=class_weight_dict  # Use the computed class weights

)

# Plot the training history

plt.figure(figsize=(14, 5))

# Plot training & validation accuracy values

plt.subplot(1, 2, 1)

plt.plot(history.history['accuracy'])

plt.plot(history.history['val_accuracy'])

plt.title('Model accuracy')

plt.xlabel('Epoch')

plt.ylabel('Accuracy')

plt.legend(['Train', 'Test'], loc='upper left')

# Plot training & validation loss values

plt.subplot(1, 2, 2)

plt.plot(history.history['loss'])

plt.plot(history.history['val_loss'])

plt.title('Model loss')

plt.xlabel('Epoch')

plt.ylabel('Loss')

plt.legend(['Train', 'Test'], loc='upper left')

plt.show()

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import LSTM, Dense, Dropout

from sklearn.utils.class_weight import compute_class_weight

# Calculate class weights for unbalanced datasets

classes = np.unique(y_train_class)

class_weights = compute_class_weight(class_weight='balanced', classes=classes, y=y_train_class)

class_weights_dict = dict(zip(classes, class_weights))

# Define the LSTM model with dropout for regularization

model = Sequential([

    LSTM(30, input_shape=(X_train.shape[1], 1), dropout=0.2, recurrent_dropout=0.2),

    Dropout(0.5),

    Dense(1, activation='sigmoid')

])

# Compile the model with a possibly smaller learning rate and class weight

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the model with class weights to handle imbalance

history = model.fit(

    X_train_rnn, y_train_class,

    epochs=50,

    validation_split=0.2,

    class_weight=class_weights_dict,

    batch_size=32  # Consider trying different batch sizes

)

# Evaluate the model to see if the performance has improved

test_loss, test_accuracy = model.evaluate(X_test_rnn, y_test_binary)

print(f"Test Loss: {test_loss}")

print(f"Test Accuracy: {test_accuracy}")

# Predict classes using the trained model

y_pred_class = (model.predict(X_test_rnn) > 0.5).astype(int)

# Generate the new confusion matrix

cm = confusion_matrix(y_test_binary, y_pred_class)

# Plot the confusion matrix

disp = ConfusionMatrixDisplay(confusion_matrix=cm)

disp.plot(cmap=plt.cm.Blues)

plt.title('Confusion Matrix')

plt.show()

from sklearn.model_selection import TimeSeriesSplit

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Bidirectional, LSTM, Dense, Dropout

from sklearn.metrics import confusion_matrix, roc_curve, auc

# Define the number of splits

n_splits = 5

tscv = TimeSeriesSplit(n_splits=n_splits)

# To store metrics for each fold

confusion_matrices = []

roc_auc_scores = []

for train_index, test_index in tscv.split(X_normalized):

    X_train_cv, X_test_cv = X_normalized[train_index], X_normalized[test_index]

    y_train_cv, y_test_cv = y_binary[train_index], y_binary[test_index]

    # Reshape the data for LSTM network

    X_train_cv_rnn = X_train_cv.reshape((X_train_cv.shape[0], X_train_cv.shape[1], 1))

    X_test_cv_rnn = X_test_cv.reshape((X_test_cv.shape[0], X_test_cv.shape[1], 1))

    # Define the model (as before)

    model = Sequential([

        Bidirectional(LSTM(50, input_shape=(X_train_cv_rnn.shape[1], 1))),

        Dropout(0.5),

        Dense(1, activation='sigmoid')

    ])

    # Compile the model (as before)

    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

    # Fit the model

    model.fit(X_train_cv_rnn, y_train_cv, epochs=100, batch_size=32, verbose=0)  # Set verbose to 0 to suppress output

    # Predict probabilities

    y_pred_probs = model.predict(X_test_cv_rnn).ravel()

    # Binarize predictions based on threshold

    threshold = 0.5  # This threshold can be adjusted

    y_pred_class = (y_pred_probs > threshold).astype(int)

    # Calculate metrics for this fold

    cm = confusion_matrix(y_test_cv, y_pred_class)

    confusion_matrices.append(cm)

    fpr, tpr, thresholds = roc_curve(y_test_cv, y_pred_probs)

    roc_auc = auc(fpr, tpr)

    roc_auc_scores.append(roc_auc)

# Now, you can calculate the average of the metrics across all folds

# Average Confusion Matrix

average_cm = np.mean(confusion_matrices, axis=0)

print("Average Confusion Matrix:\n", average_cm)

# Average ROC AUC Score

average_roc_auc = np.mean(roc_auc_scores)

print("Average ROC AUC Score:", average_roc_auc)

import numpy as np

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

import matplotlib.pyplot as plt

# Assume 'model' is your trained Keras model

# Predict probabilities for the test set

y_pred_probs = model.predict(X_test_rnn)

# Function to apply threshold to probabilities to create binary predictions

def apply_threshold(probs, threshold):

    return (probs > threshold).astype(int)

# Choose a range of thresholds to try

thresholds = np.linspace(0, 1, 101)

# Plot confusion matrices for various thresholds

fig, axes = plt.subplots(nrows=10, ncols=10, figsize=(20, 20))  # Adjust the subplot grid as needed

axes = axes.flatten()  # Flatten to 1D array for easy iteration

for ax, threshold in zip(axes, thresholds):

    # Get binary predictions using the current threshold

    y_pred_class = apply_threshold(y_pred_probs, threshold)

    # Compute the confusion matrix for this threshold

    cm = confusion_matrix(y_test_binary, y_pred_class)

    # Plot the confusion matrix

    ConfusionMatrixDisplay(confusion_matrix=cm).plot(cmap=plt.cm.Blues, ax=ax)

    ax.title.set_text(f'Thr {threshold:.2f}')

plt.tight_layout()  # Adjust spacing

plt.show()

from sklearn.metrics import roc_curve, auc

import matplotlib.pyplot as plt

# Assume 'model' is your trained Keras model and you have a test set 'X_test_rnn'

# Predict probabilities for the positive class (damage)

y_pred_probs = model.predict(X_test_rnn).ravel()

# Compute ROC curve and ROC area for each class

fpr, tpr, thresholds = roc_curve(y_test_binary, y_pred_probs)

roc_auc = auc(fpr, tpr)

# Plot the ROC curve

plt.figure()

plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)

plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')

plt.xlim([0.0, 1.0])

plt.ylim([0.0, 1.05])

plt.xlabel('False Positive Rate')

plt.ylabel('True Positive Rate')

plt.title('Receiver Operating Characteristic')

plt.legend(loc="lower right")

plt.show()

##using a bidirectional LSTM model

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Bidirectional, LSTM, Dense, Dropout

# Define the bidirectional LSTM model

bidirectional_lstm_model = Sequential([

    Bidirectional(LSTM(50, return_sequences=True), input_shape=(X_train.shape[1], 1)),

    Dropout(0.5),

    Bidirectional(LSTM(50)),

    Dropout(0.5),

    Dense(1, activation='sigmoid')

])

# Compile the model

bidirectional_lstm_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the model

history = bidirectional_lstm_model.fit(

    X_train_rnn, y_train_class,

    epochs=100,

    validation_split=0.2

)

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, roc_curve, auc

import matplotlib.pyplot as plt

# Make predictions on the test data

y_pred_probs = bidirectional_lstm_model.predict(X_test_rnn)

y_pred_class = (y_pred_probs > 0.5).astype(int)

# Confusion Matrix

cm = confusion_matrix(y_test_binary, y_pred_class)

disp = ConfusionMatrixDisplay(confusion_matrix=cm)

disp.plot(cmap=plt.cm.Blues)

plt.title('Confusion Matrix')

plt.show()

# ROC Curve

fpr, tpr, thresholds = roc_curve(y_test_binary, y_pred_probs)

roc_auc = auc(fpr, tpr)

plt.figure()

plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)

plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')

plt.xlim([0.0, 1.0])

plt.ylim([0.0, 1.05])

plt.xlabel('False Positive Rate')

plt.ylabel('True Positive Rate')

plt.title('Receiver Operating Characteristic')

plt.legend(loc="lower right")

plt.show()

from sklearn.model_selection import TimeSeriesSplit

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Bidirectional, LSTM, Dense, Dropout

from sklearn.metrics import confusion_matrix, roc_curve, auc

# Define the number of splits

n_splits = 5

tscv = TimeSeriesSplit(n_splits=n_splits)

# To store metrics for each fold

confusion_matrices = []

roc_auc_scores = []

for train_index, test_index in tscv.split(X_normalized):

    X_train_cv, X_test_cv = X_normalized[train_index], X_normalized[test_index]

    y_train_cv, y_test_cv = y_binary[train_index], y_binary[test_index]

    # Reshape the data for LSTM network

    X_train_cv_rnn = X_train_cv.reshape((X_train_cv.shape[0], X_train_cv.shape[1], 1))

    X_test_cv_rnn = X_test_cv.reshape((X_test_cv.shape[0], X_test_cv.shape[1], 1))

    # Define the model (as before)

    model = Sequential([

        Bidirectional(LSTM(50, input_shape=(X_train_cv_rnn.shape[1], 1))),

        Dropout(0.5),

        Dense(1, activation='sigmoid')

    ])

    # Compile the model (as before)

    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

    # Fit the model

    model.fit(X_train_cv_rnn, y_train_cv, epochs=100, batch_size=32, verbose=0)  # Set verbose to 0 to suppress output

    # Predict probabilities

    y_pred_probs = model.predict(X_test_cv_rnn).ravel()

    # Binarize predictions based on threshold

    threshold = 0.5  # This threshold can be adjusted

    y_pred_class = (y_pred_probs > threshold).astype(int)

    # Calculate metrics for this fold

    cm = confusion_matrix(y_test_cv, y_pred_class)

    confusion_matrices.append(cm)

    fpr, tpr, thresholds = roc_curve(y_test_cv, y_pred_probs)

    roc_auc = auc(fpr, tpr)

    roc_auc_scores.append(roc_auc)

# Now, you can calculate the average of the metrics across all folds

# Average Confusion Matrix

average_cm = np.mean(confusion_matrices, axis=0)

print("Average Confusion Matrix:\n", average_cm)

# Average ROC AUC Score

average_roc_auc = np.mean(roc_auc_scores)

print("Average ROC AUC Score:", average_roc_auc)