SDG 6 - Project Mobile App.

To tailor the solution for larger datasets and integrate predictive analytics with external tools like IoT sensors, here's how you can proceed:

1. Using a Larger Dataset

• Collect historical data on water usage, temperature, humidity, and other factors (e.g., time of day, seasonality).

• Example sources: 

o IoT-enabled water flow meters.

o Public datasets on water usage (e.g., from municipal water boards or organizations like India Water Portal).

• If you have a dataset, format it into a CSV file and load it for analysis.

# Load Larger Dataset

import pandas as pd

data = pd.read_csv("large_water_usage_data.csv")  # Replace with your dataset

X = data[["Household Size", "Avg Temperature (°C)", "Humidity (%)", "Season"]]

y = data["Water Usage (Liters)"]

2. Integrating IoT Sensors

• IoT Devices for Water Monitoring: 

o Sensors like Flume Water Monitor or IoT-enabled Smart Meters.

• Use APIs provided by IoT platforms to collect real-time data. Examples: 

o ThingsBoard for IoT data management.

o AWS IoT Core for cloud-based IoT solutions.

Example of retrieving IoT data via an API:

import requests

# Fetch IoT Data

iot_url = "http://iot-platform/api/water_usage"

response = requests.get(iot_url)

iot_data = response.json()

# Convert to DataFrame

iot_df = pd.DataFrame(iot_data)

3. Enhancing the Model

• Add more features like: 

o Time of day (e.g., morning, afternoon).

o Seasonal variations (e.g., rainy, summer).

o Water pressure.

• Use advanced algorithms like Gradient Boosting (e.g., XGBoost) for better predictions.

from xgboost import XGBRegressor

# Train Gradient Boosting Model

xgb_model = XGBRegressor()

xgb_model.fit(X_train, y_train)

# Predict and Evaluate

y_pred_xgb = xgb_model.predict(X_test)

print("R-squared for XGBoost:", r2_score(y_test, y_pred_xgb))

4. Real-Time Monitoring and Alerts

• Use dashboards for real-time tracking.

• Tools like Grafana or Tableau can visualize predictions and actual water usage.

• Example workflow: 

o Use IoT data to make predictions.

o Trigger alerts when usage exceeds a predefined threshold.

# Example: Alert for High Water Usage

if predicted_usage[0] > 200:  # Threshold

    print("Alert: High water usage detected!")

5. Deployment

• Deploy the predictive model as a web app using tools like: 

o Flask or Django for backend services.

o Streamlit for an interactive UI to monitor predictions.

Example with Streamlit:

6. Actionable Outputs

• Optimize Water Usage: Recommendations based on usage patterns.

• Leak Detection: Identify anomalies using real-time IoT data.

• Community Planning: Use aggregated data for locality-level predictions.

Would you like help setting up any specific integration or deployment environment?

---------------------------------------------------------------------------------------------------------------------------

We'll aim to build a Streamlit app for real-time predictions and monitoring.

#pip install streamlit

import streamlit as st

# Streamlit App

st.title("Predictive Analytics for Water Usage")

st.write("Enter parameters to predict water usage:")

size = st.number_input("Household Size", min_value=1, max_value=20)

temp = st.number_input("Average Temperature (°C)", min_value=0, max_value=50)

if st.button("Predict"):

    prediction = model.predict([[size, temp]])

    st.write(f"Predicted Water Usage: {prediction[0]:.2f} liters/day")

Run the app:

streamlit run app.py

_________________________________

1. Setting Up IoT Data Integration

Assume you have IoT devices monitoring water flow, temperature, and other parameters. Use APIs or MQTT to fetch real-time data.

Example: Fetch Data via API

import requests

import pandas as pd

# API URL for IoT Data

iot_api_url = "http://iot-platform/api/water_usage"  # Replace with actual URL

# Fetch Real-Time Data

response = requests.get(iot_api_url)

if response.status_code == 200:

    iot_data = response.json()

    df = pd.DataFrame(iot_data)

    print(df.head())

else:

    print("Failed to fetch data from IoT API")

________________________________________

2. Train the Predictive Model

Use historical data to train a model. Here’s an example using Random Forest:

import requests

# Fetch IoT Data

iot_url = "http://iot-platform/api/water_usage"

response = requests.get(iot_url)

iot_data = response.json()

# Convert to DataFrame

iot_df = pd.DataFrame(iot_data)

from sklearn.model_selection import train_test_split

from sklearn.ensemble import RandomForestRegressor

import pickle

# Load Dataset

data = pd.read_csv("historical_water_usage.csv")  # Replace with actual data file

X = data[["Household Size", "Avg Temperature (°C)"]]

y = data["Water Usage (Liters)"]

# Train-Test Split

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

# Train Model

model = RandomForestRegressor(n_estimators=100, random_state=42)

model.fit(X_train, y_train)

# Save Model

with open("water_usage_model.pkl", "wb") as file:

    pickle.dump(model, file)

________________________________________

3. Build a Streamlit App

Create a simple app to fetch IoT data, use the model for predictions, and display results.

Install Streamlit:

Code for the App:

#pip install streamlit

import streamlit as st

import pandas as pd

import requests

import pickle

# Load Trained Model

with open("water_usage_model.pkl", "rb") as file:

    model = pickle.load(file)

# Fetch IoT Data

def fetch_iot_data():

    iot_api_url = "http://iot-platform/api/water_usage"  # Replace with actual URL

    response = requests.get(iot_api_url)

    if response.status_code == 200:

        return pd.DataFrame(response.json())

    else:

        st.error("Failed to fetch data from IoT API")

        return pd.DataFrame()

# Streamlit App

st.title("Water Demand Prediction and Monitoring")

st.sidebar.header("Input Parameters")

# Input Fields

household_size = st.sidebar.slider("Household Size", 1, 20, 5)

temperature = st.sidebar.slider("Average Temperature (°C)", 10, 50, 30)

if st.sidebar.button("Predict Water Usage"):

    prediction = model.predict([[household_size, temperature]])

    st.write(f"Predicted Water Usage: **{prediction[0]:.2f} liters/day**")

# Real-Time Monitoring

st.header("Real-Time IoT Data")

iot_data = fetch_iot_data()

if not iot_data.empty:

    st.write(iot_data)

else:

    st.write("No IoT data available.")

#4. Run the App

#Save the file as app.py and run it using:

#streamlit run app.py

5. Deploy the Application

You can deploy this app using platforms like:

1. Streamlit Cloud (free for simple apps):

o Log in to Streamlit Cloud.

o Link your GitHub repository and deploy.

2. Heroku:

o Create a requirements.txt: 

o streamlit

o scikit-learn

o pandas

o requests

o Create a Procfile: 

o web: streamlit run app.py --server.port=$PORT

o Deploy using Heroku CLI: 

o heroku login

o heroku create

o git push heroku main

3. AWS or Azure:

o Set up a virtual machine with Python and Streamlit installed.

o Expose the app on a public IP or domain.

________________________________________

6. Future Enhancements

• Add Water Conservation Tips: Provide recommendations based on water usage trends.

• Anomaly Detection: Use machine learning to detect leaks or unusual water usage patterns.

• User Notifications: Send SMS or email alerts for high water usage using services like Twilio.

• Dashboard Integration: Combine Streamlit with dashboards (e.g., Grafana) for better data visualization.

Would you like help deploying the app or enhancing its features?

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Let’s deploy the Streamlit app and enhance its features step by step. We'll use Streamlit Cloud for deployment (free and user-friendly) and discuss enhancements you can add.

________________________________________

1. Preparing the Project for Deployment

1. Project Structure: Create a folder containing:

o app.py: The Streamlit app script.

o water_usage_model.pkl: The trained model file.

o requirements.txt: List of dependencies.

2. Creating requirements.txt: Include all libraries used in the project.

3. streamlit

4. pandas

5. scikit-learn

6. requests

7. numpy

8. pickle5

Install them locally to test:

pip install -r requirements.txt

9. Test Locally: Run the app to ensure it works before deployment:

10. streamlit run app.py

________________________________________

2. Deploying on Streamlit Cloud

1. Create a GitHub Repository:

o Upload all project files to a new repository.

2. Deploy on Streamlit Cloud:

o Go to Streamlit Cloud.

o Log in and click "New App".

o Select your repository and branch.

o Specify the app.py file as the entry point.

3. Test Your App Online: Once deployed, you'll get a public URL for your app. Share it with users for feedback.

________________________________________

3. Enhancements to the App

A. Add Water Conservation Tips

Provide suggestions based on predictions:

# Display Conservation Tips

if prediction[0] > 200:

    st.warning("High water usage detected! Consider reducing usage by:\n"

               "- Fixing leaks.\n"

               "- Using low-flow fixtures.\n"

               "- Reusing greywater for non-drinking purposes.")

B. Real-Time Notifications

Send SMS/email alerts for excessive water usage using Twilio:

pip install twilio

from twilio.rest import Client

def send_alert(predicted_usage):

    account_sid = "your_account_sid"

    auth_token = "your_auth_token"

    client = Client(account_sid, auth_token)

    message = client.messages.create(

        body=f"Alert: High water usage detected - {predicted_usage:.2f} liters/day.",

        from_="+1234567890",  # Twilio number

        to="+0987654321"      # Your phone number

    )

    return message.sid

if prediction[0] > 200:

    send_alert(prediction[0])

C. Add Data Visualization

Include plots to show historical and predicted water usage trends:

import matplotlib.pyplot as plt

# Plot Historical Data

st.subheader("Water Usage Trends")

fig, ax = plt.subplots()

ax.plot(data["Date"], data["Water Usage (Liters)"], label="Historical Usage")

ax.axhline(y=prediction[0], color='r', linestyle='--', label="Predicted Usage")

ax.legend()

st.pyplot(fig)