Upload 15 files

app.py

@@ -0,0 +1,222 @@
+# import libraries
+import streamlit as st
+import joblib
+import numpy as np
+import pandas as pd
+
+st.set_page_config(
+    page_title="NASA Turbofan Playground",
+    page_icon="🧊",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://www.extremelycoolapp.com/help',
+        'Report a bug': "https://www.extremelycoolapp.com/bug",
+        'About': "# This is a header. This is an *extremely* cool app!"
+    }
+)
+
+# Set the background image
+background_image = """
+<style>
+[data-testid="stAppViewContainer"] > .main {
+    background-image: url("https://w.wallhaven.cc/full/q6/wallhaven-q6vpxr.png");
+    background-size: 100vw 100vh;  # This sets the size to cover 100% of the viewport width and height
+    background-position: center;  
+    background-repeat: no-repeat;
+}
+</style>
+"""
+
+st.markdown(background_image, unsafe_allow_html=True)
+
+
+# Title with Rainbow Transition Effect and Neon Glow
+html_code = """
+<div class="title-container">
+  <h1 class="neon-text">
+    NASA Turbofan Playground
+  </h1>
+</div>
+
+<style>
+@keyframes rainbow-text-animation {
+  0% { color: red; }
+  16.67% { color: orange; }
+  33.33% { color: yellow; }
+  50% { color: green; }
+  66.67% { color: blue; }
+  83.33% { color: indigo; }
+  100% { color: violet; }
+}
+
+.title-container {
+  text-align: center;
+  margin: 1em 0;
+  padding-bottom: 10px;
+  border-bottom: 4  px solid #fcdee9; /* Magenta underline */
+}
+
+.neon-text {
+  font-family: Times New Roman, sans-serif;
+  font-size: 4em;
+  margin: 0;
+  animation: rainbow-text-animation 5s infinite linear;
+  text-shadow: 0 0 5px rgba(255, 255, 255, 0.8),
+               0 0 10px rgba(255, 255, 255, 0.7),
+               0 0 20px rgba(255, 255, 255, 0.6),
+               0 0 40px rgba(255, 0, 255, 0.6),
+               0 0 80px rgba(255, 0, 255, 0.6),
+               0 0 90px rgba(255, 0, 255, 0.6),
+               0 0 100px rgba(255, 0, 255, 0.6),
+               0 0 150px rgba(255, 0, 255, 0.6);
+}
+</style>
+"""
+
+st.markdown(html_code, unsafe_allow_html=True)
+st.divider()
+
+st.markdown(
+    """
+    <style>
+    .success-message {
+        font-family: Arial, sans-serif;
+        font-size: 24px;
+        color: green;
+        text-align: left;
+    }
+    .wng_txt {
+        font-family: Arial, sans-serif;
+        font-size: 24px;
+        color: yellow;
+        text-align: left;
+    }
+    .unsuccess-message {
+        font-family: Arial, sans-serif;
+        font-size: 22px;
+        color: red;
+        text-align: left;
+    }
+    .prompt-message {
+        font-family: Arial, sans-serif;
+        font-size: 24px;
+        color: #333;
+        text-align: center;
+    }
+    .success-message2 {
+        font-family: Arial, sans-serif;
+        font-size: 18px;
+        color: white;
+        text-align: left;
+    }
+    .inf_txt {
+        font-family: Arial, sans-serif;
+        font-size: 28px;
+        color: white;
+        text-align: left;
+    }
+    .message-box {
+        text-align: center;
+        background-color: white;
+        padding: 5px;
+        border-radius: 10px;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+        font-size: 24px;
+        color: #333;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+
+# Load your ML model
+model = joblib.load('random_forest_model.joblib')
+
+# Define the columns and their min/max values along with descriptions
+columns = {
+    'cycles': {'min': 1, 'max': 362, 'type': 'int', 'desc': 'Number of operational cycles the turbofan engine has undergone.'},
+    'T24': {'min': 641.21, 'max': 644.53, 'type': 'float', 'desc': 'Total temperature at fan inlet (sensor measurement).'},
+    'T30': {'min': 1571.04, 'max': 1616.91, 'type': 'float', 'desc': 'Total temperature at Low-Pressure Compressor (LPC) outlet (sensor measurement).'},
+    'T50': {'min': 1382.25, 'max': 1441.49, 'type': 'float', 'desc': 'Total temperature at High-Pressure Turbine (HPT) outlet (sensor measurement).'},
+    'P30': {'min': 549.85, 'max': 556.06, 'type': 'float', 'desc': 'Pressure at HPC outlet (sensor measurement).'},
+    'Nf': {'min': 2387.90, 'max': 2388.56, 'type': 'float', 'desc': 'Physical fan speed (shaft rotational speed).'},
+    'Nc': {'min': 9021.73, 'max': 9244.59, 'type': 'float', 'desc': 'Physical core speed (shaft rotational speed).'},
+    'Ps30': {'min': 46.85, 'max': 48.53, 'type': 'float', 'desc': 'Static pressure at HPC outlet (sensor measurement).'},
+    'phi': {'min': 518.69, 'max': 523.38, 'type': 'float', 'desc': 'Ratio of fuel flow to the engine core airflow (calculated parameter).'},
+    'NRf': {'min': 2387.88, 'max': 2388.56, 'type': 'float', 'desc': 'Corrected fan speed (shaft rotational speed).'},
+    'NRc': {'min': 8099.94, 'max': 8293.72, 'type': 'float', 'desc': 'Corrected core speed (shaft rotational speed).'},
+    'BPR': {'min': 8.3249, 'max': 8.5848, 'type': 'float', 'desc': 'Bypass ratio (ratio of the mass of air bypassing the engine core to the mass of air passing through the core).'},
+    'htBleed': {'min': 388.00, 'max': 400.00, 'type': 'float', 'desc': 'Bleed Enthalpy (energy loss due to air bled off for use in other aircraft systems).'},
+    'W31': {'min': 38.14, 'max': 39.43, 'type': 'float', 'desc': 'High-pressure turbine cooling bleed flow (sensor measurement).'},
+    'W32': {'min': 22.8942, 'max': 23.6184, 'type': 'float', 'desc': 'Low-pressure turbine cooling bleed flow (sensor measurement).'}
+}
+
+# Sidebar inputs
+st.sidebar.title("NASA Turbofan Playground")
+inputs = {}
+for col, limits in columns.items():
+    if limits['type'] == 'int':
+        inputs[col] = st.sidebar.number_input(col, min_value=limits['min'], max_value=limits['max'], value=(limits['min'] + limits['max']) // 2, step=1, help=limits['desc'])
+    else:
+        inputs[col] = st.sidebar.number_input(col, min_value=limits['min'], max_value=limits['max'], value=(limits['min'] + limits['max']) / 2, help=limits['desc'])
+
+# Main page
+# st.title("Turbofan Engine RUL Prediction")
+st.markdown('<p class="message-box">Turbofan Engine RUL Prediction</p>', unsafe_allow_html=True)
+st.markdown('<p class="success-message2">Provide the necessary inputs in the sidebar to predict the Remaining Useful Life (RUL) of the turbofan engine.</p>', unsafe_allow_html=True)
+# st.write("Provide the necessary inputs in the sidebar to predict the Remaining Useful Life (RUL) of the turbofan engine.")
+
+# Prepare the input for prediction
+input_data = [inputs[col] for col in columns]
+input_data = [input_data]  # Assuming the model expects a 2D array
+
+# Predict the RUL
+if st.sidebar.button("Predict RUL"):
+    prediction = model.predict(input_data)
+    predicted_rul = int(prediction[0])
+    input_cycles = inputs['cycles']
+    
+    # Calculate percentage of RUL
+    percentage_rul = input_cycles / predicted_rul
+    st.divider()
+    st.subheader(f"The predicted Remaining Useful Life (RUL) is: {predicted_rul} cycles")
+    st.divider()
+ 
+    # Determine engine health status
+    if percentage_rul >=1:
+        
+        st.markdown('<p class="unsuccess-message">The RUL is less than Current Cycle, this may be due to wrong prediction or Sensor Anomalies.</p>', unsafe_allow_html=True)
+        max_deviation = 0
+        anomaly_sensor = None
+        for col, limits in columns.items():
+            deviation = min(abs(inputs[col] - limits['min']), abs(inputs[col] - limits['max']))
+            if deviation > max_deviation:
+                max_deviation = deviation
+                anomaly_sensor = col
+        st.markdown(f'<p class="unsuccess-message">Potential anomaly detected in sensor: {anomaly_sensor}.</p>', unsafe_allow_html=True)
+        
+    elif percentage_rul < 0.4:
+        st.markdown('<p class="success-message">The Remaining Useful is more than 60%, \nEngine Health is Excellent.</p>', unsafe_allow_html=True)
+        
+    elif percentage_rul < 0.6:
+        
+        st.markdown('<p class="success-message">The Remaining Useful is more than 40%, \nEngine Health is Fine.</p>', unsafe_allow_html=True)
+    elif percentage_rul < 0.8:
+        
+        st.markdown('<p class="wng_txt">Warning: The Remaining Useful is between 60 to 80%, \nEngine needs to be checked.</p>', unsafe_allow_html=True)
+    else:
+        st.markdown('<p class="unsuccess-message">Warning: The Remaining Useful is critical and less than 20%, \nEngine maintenance Required.</p>', unsafe_allow_html=True)
+        
+        # Identify the sensor responsible for the anomaly
+        max_deviation = 0
+        anomaly_sensor = None
+        for col, limits in columns.items():
+            deviation = min(abs(inputs[col] - limits['min']), abs(inputs[col] - limits['max']))
+            if deviation > max_deviation:
+                max_deviation = deviation
+                anomaly_sensor = col
+        
+        st.markdown(f'<p class="unsuccess-message">Potential anomaly detected in sensor: {anomaly_sensor}.</p>', unsafe_allow_html=True)
+
+   

evaluationer.py

@@ -0,0 +1,151 @@
+# importing libraries
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import root_mean_squared_error,r2_score,mean_squared_error,root_mean_squared_log_error,mean_absolute_error,mean_squared_log_error
+from sklearn.metrics import f1_score, accuracy_score, precision_score,recall_score, average_precision_score
+# creating a class for evaluation
+    
+reg_evaluation_df = pd.DataFrame({"evaluation_df_method" :[],
+                                "model": [],# model displays regression model
+                                "method": [],# method display evaluation metrics used
+                                "train_r2": [],# train r2 shows train R2 score
+                                "test_r2": [],# test r2 shows test R2 Score
+                                "adjusted_r2_train": [],# adjusted_r2_train shows adjusted r2 score for train
+                                "adjusted_r2_test": [],# adjusted_r2_test shows adjusted r2 score for test
+                                "train_evaluation": [],# train_evaluation shows train evaluation score by used method
+                                "test_evaluation" : []# test_evaluation shows test evaluation score by used method
+                            })
+
+classification_evaluation_df = pd.DataFrame({"evaluation_df_method" :[],
+                        'model': [],
+                        'train_f1': [],
+                        'test_f1': [],
+                        'train_acc': [],
+                        'test_acc': [],
+                        'precision_train': [],
+                        'precision_test': [],
+                        'recall_train': [],
+                        'recall_test': []
+                    })
+
+# function for evaluating dataframe
+def evaluation(evaluation_df_method,X_train,X_test,y_train,y_test,model,method,eva):# input parameters from train_test_split , model and method for evaluation.
+    global y_pred_train,y_pred_test,y_pred_proba_train,y_pred_proba_test
+    model = model
+    model.fit(X_train,y_train) # model fitting
+    y_pred_train = model.predict(X_train) # model prediction for train
+    y_pred_test = model.predict(X_test) # model prediction for test
+
+    if eva == "reg":
+        
+        train_r2 = r2_score(y_train, y_pred_train) # evaluating r2 score for train
+        test_r2 = r2_score(y_test, y_pred_test)  # evaluating r2 score for test
+        
+        n_r_train, n_c_train = X_train.shape # getting no of rows and columns of train data
+        n_r_test,  n_c_test = X_test.shape # getting no of rows and columns of test data
+        
+        adj_r2_train = 1 - ((1 - train_r2)*(n_r_train - 1)/ (n_r_train - n_c_train - 1))  # evaluating adjusted r2 score for train
+        adj_r2_test = 1 - ((1 - test_r2)*(n_r_test - 1)/ (n_r_test - n_c_test - 1)) # evaluating adjusted r2 score for test
+    
+        train_evaluation = method(y_train, y_pred_train) # evaluating train error
+        test_evaluation = method(y_test, y_pred_test) # evaluating test error
+        
+        if method == root_mean_squared_error:
+            a = "root_mean_squared_error"
+        elif method ==root_mean_squared_log_error:
+            a = "root_mean_squared_log_error"
+        elif method == mean_absolute_error:
+            a = "mean_absolute_error"
+        elif method == mean_squared_error:
+            a = "mean_squared_error"
+        elif method == mean_squared_log_error:
+            a = "mean_squared_log_error"    
+        
+        # declaring global dataframes
+        global reg_evaluation_df,temp_df
+        
+        # creating temporary dataframe for concating in later into main evaluation dataframe
+        temp_df = pd.DataFrame({"evaluation_df_method" :[evaluation_df_method],
+                                    "model": [model],
+                                    "method": [a],
+                                    "train_r2": [train_r2],
+                                    "test_r2": [test_r2],
+                                    "adjusted_r2_train": [adj_r2_train],
+                                    "adjusted_r2_test": [adj_r2_test],
+                                    "train_evaluation": [train_evaluation],
+                                    "test_evaluation" : [test_evaluation]
+                                    })
+        reg_evaluation_df = pd.concat([reg_evaluation_df,temp_df]).reset_index(drop = True)
+        
+
+
+        
+        return reg_evaluation_df # returning evaluation_df
+
+    elif eva == "class":
+                
+        # y_pred_proba_train= model.predict_proba(X_train)
+        # y_pred_proba_test= model.predict_proba(X_test)
+
+        unique_classes = np.unique(y_train)
+    
+        # Determine the average method
+        if len(unique_classes) == 2:
+            # Binary classification
+            print("Using 'binary' average for binary classification.")
+            average_method = 'binary'
+        elif len(unique_classes)!=2:
+            # Determine the distribution of the target column
+            class_counts = np.bincount(y_train)
+            
+            # Check if the dataset is imbalanced
+            imbalance_ratio = max(class_counts) / min(class_counts)
+            
+            if imbalance_ratio > 1.5:
+                # Imbalanced dataset
+                print("Using 'weighted' average due to imbalanced dataset.")
+                average_method = 'weighted'
+            else:
+                # Balanced dataset
+                print("Using 'macro' average due to balanced dataset.")
+                average_method = 'macro'
+            
+        # F1 scores
+        train_f1_scores = (f1_score(y_train, y_pred_train,average=average_method))
+        test_f1_scores = (f1_score(y_test, y_pred_test,average=average_method))    
+    
+        # Accuracies
+        train_accuracies = (accuracy_score(y_train, y_pred_train))
+        test_accuracies = (accuracy_score(y_test, y_pred_test))
+    
+        # Precisions
+        train_precisions = (precision_score(y_train, y_pred_train,average=average_method))
+        test_precisions = (precision_score(y_test, y_pred_test,average=average_method))
+    
+        # Recalls
+        train_recalls = (recall_score(y_train, y_pred_train,average=average_method))
+        test_recalls = (recall_score(y_test, y_pred_test,average=average_method))
+        
+        # declaring global dataframes
+        global classification_evaluation_df,temp_df1
+        
+        # creating temporary dataframe for concating in later into main evaluation dataframe
+        temp_df1 = pd.DataFrame({"evaluation_df_method" :[evaluation_df_method],
+            'model': [model],
+            'train_f1': [train_f1_scores],
+            'test_f1': [test_f1_scores],
+            'train_acc': [train_accuracies],
+            'test_acc': [test_accuracies],
+            'precision_train': [train_precisions],
+            'precision_test': [test_precisions],
+            'recall_train': [train_recalls],
+            'recall_test': [test_recalls]
+        })
+        classification_evaluation_df = pd.concat([classification_evaluation_df, temp_df1]).reset_index(drop = True)
+        
+        return classification_evaluation_df # returning evaluation_df
+
+global method_df
+method_df = pd.DataFrame(data = [root_mean_squared_error, root_mean_squared_log_error,mean_absolute_error,mean_squared_error,mean_squared_log_error],
+                         index = ["root_mean_squared_error", "root_mean_squared_log_error","mean_absolute_error","mean_squared_error","mean_squared_log_error"])

models.py

@@ -0,0 +1,70 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+# import algorithms for classification 
+from sklearn.linear_model import LogisticRegression, SGDClassifier, RidgeClassifier
+from sklearn.ensemble import RandomForestClassifier,AdaBoostClassifier,GradientBoostingClassifier,HistGradientBoostingClassifier
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.svm import SVC
+from xgboost import XGBClassifier,XGBRFClassifier 
+from sklearn.neural_network import MLPClassifier
+from lightgbm import LGBMClassifier
+from sklearn.naive_bayes import MultinomialNB,CategoricalNB
+# import algorithms for regression
+from sklearn.linear_model import LinearRegression, SGDRegressor, Ridge, Lasso, ElasticNet
+from sklearn.ensemble import RandomForestRegressor,AdaBoostRegressor,GradientBoostingRegressor,HistGradientBoostingRegressor
+from sklearn.neighbors import KNeighborsRegressor
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.svm import SVR
+from xgboost import XGBRegressor, XGBRFRegressor
+from sklearn.neural_network import MLPRegressor
+from lightgbm import LGBMRegressor
+from sklearn.naive_bayes import GaussianNB
+
+
+
+# dictionary where keys are name of algorithm and values are algorithm for classifier
+algos_class = {
+    "Logistic Regression": LogisticRegression(),
+    "SGD Classifier": SGDClassifier(),
+    "Ridge Classifier": RidgeClassifier(),
+    "Random Forest Classifier": RandomForestClassifier(),
+    "AdaBoost Classifier": AdaBoostClassifier(),
+    "Gradient Boosting Classifier": GradientBoostingClassifier(),
+    "Hist Gradient Boosting Classifier": HistGradientBoostingClassifier(),
+    "K Neighbors Classifier": KNeighborsClassifier(),
+    "Decision Tree Classifier": DecisionTreeClassifier(),
+    "SVC": SVC(),
+    "XGB Classifier": XGBClassifier(),
+    "XGBRF Classifier": XGBRFClassifier(),
+    "MLP Classifier": MLPClassifier(),
+    "LGBM Classifier": LGBMClassifier(),
+    "Multinomial Naive Bayes": MultinomialNB(),
+    "Categorical Naive Bayes": CategoricalNB()}
+
+# dictionary where keys are name of algorithm and values are algorithm for regression
+algos_reg = {
+    "Linear Regression": LinearRegression(),
+    "Ridge Regressor": Ridge(),
+    "Lasso Regressor": Lasso(),
+    "ElasticNet Regressor": ElasticNet(),
+    "Random Forest Regressor": RandomForestRegressor(),
+    "AdaBoost Regressor": AdaBoostRegressor(),
+    "Gradient Boosting Regressor": GradientBoostingRegressor(),
+    "Hist Gradient Boosting Regressor": HistGradientBoostingRegressor(),
+    "K Neighbors Regressor": KNeighborsRegressor(),
+    "Decision Tree Regressor": DecisionTreeRegressor(),
+    "XGB Regressor": XGBRegressor(),
+    "XGBRF Regressor": XGBRFRegressor(),
+    "MLP Regressor": MLPRegressor(),
+    "LGBM Regressor": LGBMRegressor(),
+    "Gaussian Naive Bayes": GaussianNB()}
+
+# dataframe where index are name of algorithm as "algorithm name" , column  is algorithm as "algorithm"
+
+Classification_models = pd.DataFrame(data=algos_class.values(), index=algos_class.keys())
+
+Regression_models = pd.DataFrame(data=algos_reg.values(), index=algos_reg.keys())
+

random_forest_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d0771ed913e1d71c04a998ad8010a96ee823e25e834f47c938e6ed5eff624bb
+size 28841249

raw_data/RUL_FD001.txt

@@ -0,0 +1,100 @@
+112 
+98 
+69 
+82 
+91 
+93 
+91 
+95 
+111 
+96 
+97 
+124 
+95 
+107 
+83 
+84 
+50 
+28 
+87 
+16 
+57 
+111 
+113 
+20 
+145 
+119 
+66 
+97 
+90 
+115 
+8 
+48 
+106 
+7 
+11 
+19 
+21 
+50 
+142 
+28 
+18 
+10 
+59 
+109 
+114 
+47 
+135 
+92 
+21 
+79 
+114 
+29 
+26 
+97 
+137 
+15 
+103 
+37 
+114 
+100 
+21 
+54 
+72 
+28 
+128 
+14 
+77 
+8 
+121 
+94 
+118 
+50 
+131 
+126 
+113 
+10 
+34 
+107 
+63 
+90 
+8 
+9 
+137 
+58 
+118 
+89 
+116 
+115 
+136 
+28 
+38 
+20 
+85 
+55 
+128 
+137 
+82 
+59 
+117 
+20 

readme.txt

@@ -0,0 +1,45 @@
+Data Set: FD001
+Train trjectories: 100
+Test trajectories: 100
+Conditions: ONE (Sea Level)
+Fault Modes: ONE (HPC Degradation)
+
+Data Set: FD002
+Train trjectories: 260
+Test trajectories: 259
+Conditions: SIX 
+Fault Modes: ONE (HPC Degradation)
+
+Data Set: FD003
+Train trjectories: 100
+Test trajectories: 100
+Conditions: ONE (Sea Level)
+Fault Modes: TWO (HPC Degradation, Fan Degradation)
+
+Data Set: FD004
+Train trjectories: 248
+Test trajectories: 249
+Conditions: SIX 
+Fault Modes: TWO (HPC Degradation, Fan Degradation)
+
+
+
+Experimental Scenario
+
+Data sets consists of multiple multivariate time series. Each data set is further divided into training and test subsets. Each time series is from a different engine � i.e., the data can be considered to be from a fleet of engines of the same type. Each engine starts with different degrees of initial wear and manufacturing variation which is unknown to the user. This wear and variation is considered normal, i.e., it is not considered a fault condition. There are three operational settings that have a substantial effect on engine performance. These settings are also included in the data. The data is contaminated with sensor noise.
+
+The engine is operating normally at the start of each time series, and develops a fault at some point during the series. In the training set, the fault grows in magnitude until system failure. In the test set, the time series ends some time prior to system failure. The objective of the competition is to predict the number of remaining operational cycles before failure in the test set, i.e., the number of operational cycles after the last cycle that the engine will continue to operate. Also provided a vector of true Remaining Useful Life (RUL) values for the test data.
+
+The data are provided as a zip-compressed text file with 26 columns of numbers, separated by spaces. Each row is a snapshot of data taken during a single operational cycle, each column is a different variable. The columns correspond to:
+1)	unit number
+2)	time, in cycles
+3)	operational setting 1
+4)	operational setting 2
+5)	operational setting 3
+6)	sensor measurement  1
+7)	sensor measurement  2
+...
+26)	sensor measurement  26
+
+
+Reference: A. Saxena, K. Goebel, D. Simon, and N. Eklund, �Damage Propagation Modeling for Aircraft Engine Run-to-Failure Simulation�, in the Proceedings of the Ist International Conference on Prognostics and Health Management (PHM08), Denver CO, Oct 2008.

requirements.txt

@@ -0,0 +1,8 @@
+streamlit==1.36.0
+joblib==1.4.2
+numpy==1.26.4
+pandas==2.2.2
+scikit-learn==1.4.2
+tensorflow==2.16.1
+matplotlib==3.9.0
+seaborn==0.13.2