Every asset has a life cycle and thus requires frequent maintenance. However, we may not want to spend resources too soon as that is a waste and we cannot be too late as it is risky. Thus, “when” to repair is an important problem.<\/p>\n
Predictive maintenance is a way to predict or forecast the probability of breakdown of a fixed asset. Predictive maintenance is important for all kinds of businesses, from a large company predicting the breakdown of motors to a small businesses predicting the breakdown of printers. It can also be used to save lives for example predict the likelihood of a factory machine breakdowns or even gas leaks.<\/p>\n
Traditionally predictive modelling is done with feature engineering and simple regression models, however these methods are difficult to reuse. We will use a more advanced LSTM models<\/a>. LSTMs have the ability to use sequences of data to make predictions on a rolling basis. The sequence of data can as small as 5 and as large as 100. For the data backend, we will use GridDB which is highly scalable and ensures high reliability. Installing GridDB is simple and is well documented here<\/a>. To check out the python-GridDB client please refer to this video<\/a>.<\/p>\n Let us setup GridDB first!<\/p>\n Download and install the deb from here<\/a>.<\/p>\n Download and install the Ubuntu from here<\/a>.<\/p>\n 1) Swig<\/p>\n 2) Install python client<\/p>\n Make sure you have python-dev installed for the corresponding python version. We will use python 3.8 for this post.<\/p>\n 3) We also need to point to the correct locations<\/p>\n We can also use GridDB with docker as shown here<\/a><\/p>\n Next we install the python libraries. Installing numpy, keras, tensorflow, sklearn and pandas is a simple pip install.<\/p>\n We use a subset of the NASA turbofan dataset<\/a> that can be downloaded from this Kaggle project<\/a>. The data has the unit number, times in cycles, three operational settings and 21 sensor measurements. The train\/test files have cycles so far and the truth file has the total number of cycles it can run.<\/p>\n Alternatively, we can use GridDB to get this data frame.<\/p>\n now we rename the columns for easy identification<\/p>\n We do the same for the truth file.<\/p>\n Next we generate the labels. We want to predict failure in the next 15 days. The data is structured such that that last cycle run is the point of failure. However in the test set the last datapoint is not present and that is available in the truth dataset. So, first we take the total cycles run so far, add the cycles left from the truth dataset to get the total time of failure. Finally we subtract the total time left with current time to get time to failure.<\/p>\n Next we assign labels based on prediction period<\/p>\n Next, we scale the data as LSTM requires data to be scaled<\/p>\n Next, we choose how many datapoints to use for LSTM. we can use 50 predictions. For this, we group the training data in groups of 50.<\/p>\n Next, we start the prediction process.<\/p>\n We first create an LSTM model in Keras. for that we use the Next, we compile the model. We use the mean_squared_error as the loss and evaluate it on accuracy.<\/p>\n Next, we train the model for 100 epochs.<\/p>\n Finally, we evaluate the test set, then we rescale the predictions and plot it along with the ground truth.<\/p>\n We can also calculate the probability of failure for every machine as follows:<\/p>\n failure prob is 0.15824139<\/p>\n Now we can play around with the prediction period, the interval for LSTM and the number of varaibles used to even get better results.<\/p>\n In this post we learned how to train an LSTM predictive maintenance model with Keras, python and GridDB. We can get a predictive accuracy of ~97% with a few lines of code.<\/p>\n","protected":false},"excerpt":{"rendered":" Every asset has a life cycle and thus requires frequent maintenance. However, we may not want to spend resources too soon as that is a waste and we cannot be too late as it is risky. Thus, “when” to repair is an important problem. Predictive maintenance is a way to predict or forecast the probability […]<\/p>\n","protected":false},"author":41,"featured_media":27842,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[121],"tags":[],"class_list":["post-46669","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog"],"acf":[],"yoast_head":"\nSetup<\/h2>\n
Quick setup of GridDB Python Client on Ubuntu 20.04:<\/h3>\n
\n
\n
\n
wget https:\/\/github.com\/swig\/swig\/archive\/refs\/tags\/v4.0.2.tar.gz \ntar xvfz v4.0.2.tar.gz \ncd swig-4.0.2 \n.\/autogen.sh \n.\/configure \nmake \n<\/code><\/pre>\n<\/div>\n\nwget \nhttps:\/\/github.com\/griddb\/python_client\/archive\/refs\/tags\/0.8.4.zip \nunzip . 0.8.4.zip \n<\/code><\/pre>\n<\/div>\nexport CPATH=$CPATH:<python header file directory path> \nexport LIBRARY_PATH=$LIBRARY_PATH:<c client library file directory path> \n\n<\/c><\/python><\/code><\/pre>\n<\/div>\nPython libraries<\/h3>\n
pip install keras \npip install numpy \npip install tensorflow \npip install pandas \npip install sklearn\n<\/code><\/pre>\n<\/div>\nPredictive Modelling<\/h2>\n
Step 1: Downloading Dataset<\/h3>\n
Step 2: Importing Libraries<\/h3>\n
\nimport pandas as pd\nimport numpy as np\nfrom sklearn.preprocessing import MinMaxScaler\nfrom sklearn.metrics import confusion_matrix, recall_score, precision_score\n\nfrom keras.models import Sequential\nfrom keras.layers import Dense, Dropout, LSTM, Activation\nfrom keras.callbacks import EarlyStopping\n<\/code><\/pre>\n<\/div>\nStep 3: Data Loading and Processing<\/h3>\n
Loading Data<\/h4>\n
\ndataset_train = pd.read_csv('\/content\/PM_train.txt',sep=' ',header=None).dropna(axis=1)\ndataset_test = pd.read_csv('\/content\/PM_test.txt',sep=' ',header=None).dropna(axis= 1)\ndataset_truth = pd.read_csv('\/content\/PM_truth.txt',sep=' ',header=None).dropna(axis=1)\n<\/code><\/pre>\n<\/div>\n import griddb_python as griddb\n\n# Initialize container\ngridstore = factory.get_store(host= host, port=port, \n cluster_name=cluster_name, username=uname, \n password=pwd)\n\nconInfo = griddb.ContainerInfo(\"attrition\",\n [[\"id\", griddb.Type.LONG],\n [\"cycle\",griddb.Type.LONG],\n .... #for all 23 variables \n griddb.ContainerType.COLLECTION, True)\n \ncont = gridstore.put_container(conInfo) \ncont.create_index(\"id\", griddb.IndexType.DEFAULT)\n<\/code><\/pre>\n<\/div>\n \nfeatures_col_name = ['os1','os2','os3','s1','s2','s3','s4','s5','s6','s7','s8','s9','s10','s11','s12','s13','s14','s15','s16','s17','s18','s19','s20','s21']\ncol_names = ['id','cycletime'] + features_col_name\ndataset_train.columns = col_names\n\n#renaming columns\ndataset_test.columns=col_names\ndataset_train.columns=col_names\n<\/code><\/pre>\n<\/div>\ndataset_truth.columns=['rul']\ndataset_truth['id']=dataset_truth.index+1\n<\/code><\/pre>\n<\/div>\n#get cycles left for train\ndataset_train['ttf'] = dataset_train.groupby(['id'])['cycletime'].transform(max) - dataset_train['cycletime']\n\n# generate column max for test data\nrul = dataset_test.groupby('id')['cycletime'].max().reset_index()\ndataset_test['ttf'] = dataset_train.groupby(['id'])['cycletime'].transform(max) - dataset_train['cycletime']\ndataset_truth['rtf'] = dataset_truth['rul'] + rul['cycletime']\ndataset_test = dataset_test.merge(pm_truth , on=['id'],how='left')\ndataset_test['ttf'] = dataset_test['rtf'] - dataset_test['cycletime']\ndataset_test.drop('rtf', axis=1, inplace=True)\n<\/code><\/pre>\n<\/div>\nperiod=15\n\ndataset_train['label'] = dataset_train['ttf'].apply(lambda x: 1 if x <= period else 0)\ndataset_test['label'] = dataset_test['ttf'].apply(lambda x: 1 if x <= period else 0)\ndataset_train.head()\n<\/code><\/pre>\n<\/div>\nsc=MinMaxScaler()\ndataset_train[features_col_name]=sc.fit_transform(dataset_train[features_col_name])\ndataset_test[features_col_name]=sc.transform(dataset_test[features_col_name])\n<\/code><\/pre>\n<\/div>\ndef gen_sequence(id_df, seq_length, seq_cols):\n df_zeros=pd.DataFrame(np.zeros((seq_length-1, id_df.shape[1])),columns=id_df.columns)\n id_df=df_zeros.append(id_df,ignore_index=True)\n data_array = id_df[seq_cols].values\n num_elements = data_array.shape[0]\n la=[]\n for start, stop in zip(range(0, num_elements-seq_length), range(seq_length, num_elements)):\n la.append(data_array[start:stop, :])\n return np.array(la)\n\n\n#generate train data\nX_train=np.concatenate(list(list(gen_sequence(dataset_train[dataset_train['id']==id], seq_length, seq_cols))\n for id in dataset_train['id'].unique()))\ny_train=np.concatenate(list(list(gen_sequence(dataset_train[dataset_train['id']==id], seq_length,['label'])) \n for id in dataset_train['id'].unique())).max(axis =1)\n\n# generate test data\nX_test=np.concatenate(list(list(gen_sequence(dataset_test[dataset_test['id']==id], seq_length, seq_cols)) \n for id in dataset_test['id'].unique()))\nprint(X_test.shape)\n\ny_test=np.concatenate(list(list(gen_sequence(dataset_test[dataset_test['id']==id], seq_length, ['label'])) \n for id in dataset_test['id'].unique())).max(axis =1)\nprint(y_test.shape)\n<\/code><\/pre>\n<\/div>\nStep 4: Prediction<\/h3>\n
Initializing<\/h4>\n
LSTM<\/code> layer.<\/p>\n \nnb_features =X_train.shape[2]\n\ntimestamp=seq_length\n\nmodel = Sequential()\n\nmodel.add(LSTM(\n input_shape=(timestamp, nb_features),\n units=100,\n return_sequences=True))\nmodel.add(Dropout(0.2))\n\nmodel.add(LSTM(\n units=seq_length,\n return_sequences=False))\nmodel.add(Dropout(0.2))\n\nmodel.add(Dense(units=1, activation='sigmoid'))\nmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n\nmodel.summary()\n<\/code><\/pre>\n<\/div>\nTraining<\/h4>\n
# fit the network\nmodel.fit(X_train, y_train, epochs=10, batch_size=200, validation_split=0.05, verbose=1,\n callbacks = [EarlyStopping(monitor='val_loss', min_delta=0, patience=0, verbose=0, mode='auto')])\n <\/code><\/pre>\n<\/div>\n \nhistory=model.fit(X_train, y_train, epochs=100, batch_size=1, verbose=1, shuffle=False) \n<\/code><\/pre>\n<\/div>\nEpoch 1\/10\n98\/98 [==============================] - 28s 250ms\/step - loss: 0.1596 - accuracy: 0.9394 - val_loss: 0.0611 - val_accuracy: 0.9679\n<\/code><\/pre>\n<\/div>\nEvaluation and Predictions<\/h4>\n
y_prob=model.predict(X_test)\ny_classes = y_prob.argmax(axis=-1)\nprint('Accuracy of model on test data: ',accuracy_score(y_test,y_classes))\n<\/code><\/pre>\n<\/div>\n\nAccuracy of model on test data: 0.9744536780547861\n <\/code><\/pre>\n<\/div>\nmachine_id = 1\nmachine_df=df_test[df_test.id==machine_id]\nmachine_test=gen_sequence(machine_df,seq_length,seq_cols)\nm_pred=model.predict(machine_test)\nfailure_prob=list(m_pred[-1]*100)[0]\n<\/code><\/pre>\n<\/div>\nConclusion<\/h2>\n