Detailed Project Plan: Smart Predictive
Maintenance System
Team: Aryan Singh, Mohit Singh, Prakhar Srivastava
Project Title: Smart Predictive Maintenance
This document provides a detailed, descriptive breakdown of your project, turning the initial
plan into an actionable, step-by-step guide.
System Architecture Overview
Before diving into the milestones, let's visualize the entire system. All the components you
build will fit together in a clear workflow.
1. A Data Simulator script on the far left sends data.
2. An arrow points to the Backend API in the center. This is the core of the system.
3. The Backend API has three arrows pointing out from it: one down to a Database cylinder,
and two to the right, pointing to a Web Dashboard and an Android App.
Milestone 1: Project Foundation & Data Acquisition (Weeks 1-3)
● Objective: Establish the project's technical foundation, select and understand a
high-quality dataset, and set up the data storage.
● Tasks:
1. Version Control & Environment Setup:
■ Why: Using Git is essential for teamwork. It allows you to track changes,
collaborate on code without overwriting each other's work, and revert to
previous versions if something breaks.
■ Action: Create a repository on GitHub. All team members will clone this
repository. Use branches for new features (e.g., feature/data-loading,
feature/api-development) and merge them into the main branch once complete.
2. Data Acquisition & Initial Analysis:
■ Action: For this project, the NASA Turbofan Engine dataset is a perfect
starting point. Each row represents one cycle (e.g., one flight), and the columns
are sensor readings. The data is organized by engine, and each engine runs until
it fails.
■ Analysis (EDA): Your first step is to understand this data. In a Jupyter Notebook,
you will plot sensor values over time for a single engine.
3. Database Setup:
■ Why: A database will store your historical data and, more importantly, your
model's predictions, which are needed for the reports. PostgreSQL is a powerful,
open-source choice.
■ Action: Design a simple schema.
● Deliverable: A shared GitHub repository, a PostgreSQL database containing the NASA
dataset, and a Jupyter Notebook detailing your findings from the EDA.
Milestone 2: ML Model Development & Training (Weeks 4-7)
● Objective: Transform the raw data into features suitable for machine learning and then
build, train, and evaluate your predictive models.
● Tasks:
1. Feature Engineering:
■ Why: Raw sensor data is often noisy. Your model will perform much better if you
provide it with more meaningful features, like trends over time.
■ Action: You will create "rolling" features. For example, a 5-cycle rolling average
for sensor_2 would be the average of the last 5 readings. This smooths out noise
and highlights the underlying trend.
2. Model Training & Evaluation:
■ Baseline Model (Random Forest): Start with this model because it's robust and
can tell you which features are most important for predicting failures.
■ Advanced Model (LSTM): LSTMs are a type of neural network designed for
sequence data. This is perfect for your problem, as the sequence of sensor
readings over time is what determines an impending failure.
■ Evaluation: A "Confusion Matrix" is the best way to understand your model's
performance.
■ Top-left square: True Positive (Correctly predicted failure).
■ Top-right square: False Positive (Predicted failure, but it didn't happen).
■ Bottom-left square: False Negative (Predicted everything is OK, but it failed).
This is the most costly error.
■ Bottom-right square: True Negative (Correctly predicted it was OK).
● Deliverable: Python scripts for cleaning data and creating features. The trained models
saved as files. A detailed report (in your notebook) comparing the performance of the
Random Forest and LSTM models.
Milestone 3: Backend API, Simulator & Reporting (Weeks 8-10)
● Objective: Build the central service that will connect your model to the outside world and
create the simulator to test it.
● Tasks:
1. Develop a Prediction & Reporting API:
■ Action: Using a Python framework like FastAPI, you'll build the server. It will have
two main functions (endpoints):
■ POST /predict: Receives a JSON object with new sensor data, passes it to
your loaded ML model, and returns a prediction.
■ GET /report/{asset_id}: Fetches all historical predictions for a specific asset
from the database and returns them as a JSON list.
■ Example Code: Here is what a simple /predict endpoint looks like in FastAPI.
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
# Load your trained model
model = [Link]('my_random_forest_model.joblib')
app = FastAPI()
class SensorData(BaseModel):
sensor1: float
sensor2: float
# ... add all other sensor features
@[Link]("/predict")
async def predict_failure(data: SensorData):
# Convert incoming data to the format your model expects
features = [[data.sensor1, data.sensor2]] # and so on
prediction = [Link](features)
probability = model.predict_proba(features)
return {
"will_fail": bool(prediction[0]),
"failure_probability": float(probability[0][1])
}
2. Create the Data Simulator:
■ Why: This script acts as your "virtual engine." It will feed data to your API just like
a real piece of equipment would, allowing you to test your entire system
end-to-end without any physical hardware.
■ Action: Write a Python script that reads your dataset row-by-row, sends each
row to the /predict endpoint, and then pauses for a few seconds to simulate a
real-time data stream.
● Deliverable: A fully functional backend application. A [Link] script that can
successfully send data to your API and get predictions back.
Milestone 4: Frontend Development (Web Dashboard & Android App)
(Weeks 11-14)
● Objective: Build the two user interfaces that will display the insights from your model in a
clear and intuitive way.
● Tasks:
1. UI/UX Design (Web & Mobile):
■ Action: Before writing any code, sketch out what your dashboard and app will
look like. Focus on clarity.
2. Web Dashboard & Android App Development:
■ Action (Web): Use a framework like React to build a Single Page Application.
■ Action (Android): Use Kotlin for native development.
● Deliverable: A functional web dashboard and a native Android app that both
successfully connect to your backend API to display live data and historical reports.
Milestone 5: System Integration, Reporting & Finalization (Weeks
15-16)
● Objective: Bring every component together, test the full system, and prepare your final
project deliverables, including the mandatory research paper.
● Tasks:
1. End-to-End Testing:
■ Action: Run everything at once! Start the database, run the backend API, start
the data simulator, and open both the web dashboard and the Android app.
Verify that the simulated data flows through the entire system and that both
frontends update in near real-time.
2. Documentation & Research Paper:
■ Documentation: Finalize the [Link] file in your GitHub repository with
clear, step-by-step instructions.
■ Research Paper: This is a mandatory deliverable. Structure it professionally with
sections for Abstract, Introduction, Methodology, Results, and Conclusion
.
● Deliverable: A fully integrated and tested application, a polished [Link], the
completed research paper, and a presentation slide deck for your final demo.