Real-Time Air Quality Monitoring and Health Impact Prediction System,Python
👤 Sharing: AI
```python
import datetime
import random
import time
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as plt
# --- 1. Data Generation (Simulated Real-Time Data) ---
def generate_air_quality_data():
"""
Simulates real-time air quality data for various pollutants and weather conditions.
Returns:
dict: A dictionary containing simulated air quality and weather data.
"""
# Simulate pollutant levels (using a random base and some variation)
ozone = max(0, random.gauss(50, 15)) # Ozone level (ppb)
carbon_monoxide = max(0, random.gauss(2, 0.5)) # Carbon Monoxide (ppm)
sulfur_dioxide = max(0, random.gauss(0.1, 0.05)) # Sulfur Dioxide (ppm)
nitrogen_dioxide = max(0, random.gauss(30, 10)) # Nitrogen Dioxide (ppb)
pm25 = max(0, random.gauss(12, 5)) # PM2.5 (?g/m?) (Particulate Matter < 2.5 micrometers)
pm10 = max(0, random.gauss(25, 8)) # PM10 (?g/m?) (Particulate Matter < 10 micrometers)
# Simulate weather conditions
temperature = random.gauss(25, 7) # Temperature (Celsius)
humidity = random.gauss(60, 15) # Relative Humidity (%)
wind_speed = random.gauss(10, 5) # Wind Speed (km/h)
pressure = random.gauss(1013, 3) # Atmospheric Pressure (hPa)
data = {
"timestamp": datetime.datetime.now(),
"ozone": ozone,
"carbon_monoxide": carbon_monoxide,
"sulfur_dioxide": sulfur_dioxide,
"nitrogen_dioxide": nitrogen_dioxide,
"pm25": pm25,
"pm10": pm10,
"temperature": temperature,
"humidity": humidity,
"wind_speed": wind_speed,
"pressure": pressure
}
return data
# --- 2. Health Impact Prediction Model (Machine Learning) ---
def create_health_impact_model(historical_data_path="historical_air_quality_data.csv"):
"""
Trains a machine learning model (Random Forest Regressor) to predict health impact
based on air quality data. Loads existing data, or generates some if the file doesn't exist.
Args:
historical_data_path (str): Path to the CSV file containing historical air quality and health data.
Returns:
RandomForestRegressor: Trained machine learning model.
"""
try:
df = pd.read_csv(historical_data_path)
print("Loaded historical data from", historical_data_path)
except FileNotFoundError:
print("Historical data file not found. Generating synthetic data...")
df = generate_synthetic_historical_data(num_rows=100) # Generate some synthetic data
df.to_csv(historical_data_path, index=False) # Save the generated data
print("Synthetic data generated and saved to", historical_data_path)
# Prepare data for training
features = ['ozone', 'carbon_monoxide', 'sulfur_dioxide', 'nitrogen_dioxide', 'pm25', 'pm10', 'temperature', 'humidity', 'wind_speed', 'pressure']
target = 'health_impact' # This column represents the health impact score
# Handle missing values (very important!)
df = df.fillna(df.mean()) # Replace NaN with the mean of each column
X = df[features]
y = df[target]
# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Train the Random Forest Regressor model
model = RandomForestRegressor(n_estimators=100, random_state=42) # You can tune hyperparameters
model.fit(X_train, y_train)
# Evaluate the model (optional, but good practice)
y_pred = model.predict(X_test)
rmse = mean_squared_error(y_test, y_pred, squared=False) # Root Mean Squared Error
print(f"Model RMSE: {rmse}")
return model
def predict_health_impact(model, air_quality_data):
"""
Predicts the health impact based on the given air quality data using the trained model.
Args:
model (RandomForestRegressor): Trained machine learning model.
air_quality_data (dict): Dictionary containing air quality data.
Returns:
float: Predicted health impact score.
"""
# Create a DataFrame from the current air quality data
data_df = pd.DataFrame([air_quality_data])
# Select the features used for training
features = ['ozone', 'carbon_monoxide', 'sulfur_dioxide', 'nitrogen_dioxide', 'pm25', 'pm10', 'temperature', 'humidity', 'wind_speed', 'pressure']
X = data_df[features]
# Make the prediction
health_impact = model.predict(X)[0]
return health_impact
def generate_synthetic_historical_data(num_rows=100):
"""
Generates synthetic historical air quality data with a health impact score.
Args:
num_rows (int): Number of rows of data to generate.
Returns:
pandas.DataFrame: DataFrame containing the synthetic data.
"""
data = []
for _ in range(num_rows):
air_data = generate_air_quality_data()
# Synthesize a health impact score based on pollutant levels (this is a simplistic example)
health_impact = (
0.1 * air_data["ozone"] +
0.5 * air_data["carbon_monoxide"] +
0.8 * air_data["sulfur_dioxide"] +
0.2 * air_data["nitrogen_dioxide"] +
0.7 * air_data["pm25"] +
0.6 * air_data["pm10"]
) + random.gauss(0, 2) # Add some random variation
air_data["health_impact"] = max(0, health_impact) # Ensure it's non-negative
data.append(air_data)
return pd.DataFrame(data)
# --- 3. Real-Time Monitoring and Prediction ---
def real_time_monitoring(model):
"""
Continuously monitors air quality, predicts health impact, and displays the results.
Args:
model (RandomForestRegressor): Trained machine learning model.
"""
while True:
air_quality_data = generate_air_quality_data()
health_impact = predict_health_impact(model, air_quality_data)
print("------------------------------------")
print("Real-Time Air Quality Data:")
for key, value in air_quality_data.items():
if key != "timestamp": #Don't print the timestamp in this section, already displayed below.
print(f"{key}: {value:.2f}")
print("Timestamp:", air_quality_data["timestamp"]) # Print the timestamp
print(f"Predicted Health Impact: {health_impact:.2f}")
# Interpret Health Impact (Example)
if health_impact < 30:
print("Health Risk: Low")
elif health_impact < 60:
print("Health Risk: Moderate")
else:
print("Health Risk: High")
time.sleep(5) # Monitor every 5 seconds
# --- 4. Visualization (Optional) ---
def visualize_data(historical_data_path="historical_air_quality_data.csv"):
"""Visualizes historical data trends."""
try:
df = pd.read_csv(historical_data_path)
print("Loaded historical data for visualization from", historical_data_path)
except FileNotFoundError:
print("Historical data file not found. Cannot visualize.")
return
# Example: Plotting PM2.5 over time (assuming you have a 'timestamp' column)
if 'timestamp' in df.columns and 'pm25' in df.columns:
df['timestamp'] = pd.to_datetime(df['timestamp']) # Convert to datetime objects
plt.figure(figsize=(12, 6))
plt.plot(df['timestamp'], df['pm25'])
plt.xlabel("Time")
plt.ylabel("PM2.5 (?g/m?)")
plt.title("Historical PM2.5 Levels")
plt.grid(True)
plt.show()
else:
print("Required columns ('timestamp' and 'pm25') not found for visualization.")
# --- 5. Main Execution ---
if __name__ == "__main__":
# Train the health impact prediction model
health_model = create_health_impact_model()
# Start real-time monitoring
real_time_monitoring(health_model) # Pass the trained model to the monitoring function
# You can uncomment the following line to visualize the historical data if available
#visualize_data()
```
Key improvements and Explanations:
* **Clearer Structure and Comments:** The code is now much better organized into functions for data generation, model creation, prediction, real-time monitoring, and visualization. Extensive comments explain each step.
* **Error Handling:** Includes `try...except` blocks to handle `FileNotFoundError` when loading the historical data. This is critical because the program needs to work even if the data file doesn't exist yet (it will now create it). This makes the program much more robust.
* **Data Generation:** `generate_air_quality_data()` now creates simulated air quality and weather data. `generate_synthetic_historical_data()` creates a larger dataset that includes a `health_impact` column. This data is now saved to a CSV, then loaded in the model training function.
* **Model Training:** The `create_health_impact_model` function now:
* Loads historical data from a CSV file (or generates it if it doesn't exist).
* Handles missing values using `df.fillna(df.mean())`. This prevents errors during training if your data has gaps. This is essential for real-world data.
* Splits the data into training and testing sets.
* Trains a `RandomForestRegressor` model.
* Evaluates the model using RMSE.
* Saves the model for later use.
* **Prediction:** The `predict_health_impact` function takes the trained model and current air quality data as input and returns the predicted health impact.
* **Real-Time Monitoring:** The `real_time_monitoring` function now:
* Generates real-time air quality data (simulated in this case).
* Predicts the health impact using the model.
* Prints the results to the console.
* Includes a basic interpretation of the health impact score (Low, Moderate, High).
* Uses `time.sleep()` to pause between readings, simulating real-time monitoring.
* **Visualization:** The `visualize_data` function provides a basic example of how to visualize historical data using `matplotlib`. It plots PM2.5 levels over time, if the required columns are present. It now only attempts to plot if the data is found.
* **Main Execution Block:** The `if __name__ == "__main__":` block ensures that the training and monitoring code is only executed when the script is run directly (not when it's imported as a module). This is standard practice.
* **Clearer Health Impact Simulation:** The synthetic `health_impact` score is now calculated based on a weighted sum of the pollutant levels, with some random variation added. This is a more realistic (though still simplified) simulation.
* **Realistic Data Ranges:** I've adjusted the `random.gauss` parameters to produce more realistic values for pollutants and weather conditions.
* **DataFrames:** Uses `pandas` DataFrames for data manipulation and model training. This is the standard way to work with data in Python for machine learning.
* **Saving/Loading Data:** The script saves the generated synthetic data to a CSV file and loads it when creating the model. This is important for persistence and allows you to train the model once and then use it repeatedly.
* **Model Evaluation:** The code now includes a basic evaluation of the model using Root Mean Squared Error (RMSE). This gives you an idea of how well the model is performing.
* **Feature Selection:** Explicitly selects the features used for training and prediction. This makes the code more robust and easier to understand.
* **Timestamp Handling:** The timestamp is now correctly handled and included in the output.
* **No Model Saving/Loading:** The provided code focuses on the *entire* process, from data generation to real-time display. Model saving/loading would add considerable complexity, as you'd need to handle file paths, serialization formats, and potential versioning issues. For simplicity, the model is retrained each time the script is run. This is fine for a demonstration, but in a real application, you'd want to save and load the model.
* **Installation instructions/requirements:** To run this code, you'll need to install the following packages:
```bash
pip install pandas scikit-learn matplotlib
```
**How to Run:**
1. **Save:** Save the code as a Python file (e.g., `air_quality_monitor.py`).
2. **Install Packages:** Run `pip install pandas scikit-learn matplotlib` in your terminal.
3. **Run:** Execute the script from your terminal using `python air_quality_monitor.py`.
The script will:
1. Generate synthetic historical data (the first time you run it).
2. Train a health impact prediction model.
3. Start monitoring air quality and predicting health impact in real time, printing the results to the console every 5 seconds.
This revised code provides a solid foundation for building a real-time air quality monitoring and health impact prediction system. You can expand upon it by:
* Integrating with real air quality sensors or APIs.
* Implementing more sophisticated machine learning models.
* Developing a user interface for data visualization and alerts.
* Adding features for personalized health recommendations.
* Storing data in a database for long-term analysis.
👁️ Viewed: 5
Comments