Module 1: Garbage Classification Preprocessing

Introduction:
The Garbage Classification Preprocessing module aims to prepare the dataset for garbage
classification into six classes: 'cardboard', 'glass', 'metal', 'paper', 'plastic', and 'trash'. This
module performs image data loading, resizing, conversion to grayscale, class distribution
visualization, and sample image visualization.

Dependencies:
- google.colab: The module assumes the code is run on Google Colab, as it mounts the Google
Drive to access the dataset.
- PIL (Python Imaging Library): Used for image processing tasks like resizing and converting to
grayscale.
- pathlib.Path: Utilized for handling file paths and directory operations.
- os: To work with file and directory paths.
- numpy: Used to handle counts for class distribution visualization.
- matplotlib.pyplot: For plotting class distribution and sample images.
- torchvision.datasets.ImageFolder: To load the dataset and apply transformations.

Functionality:

Data Loading and Image Resizing:

● The code imports the necessary libraries and mounts Google Drive to access the
dataset zip file located at
'/content/drive/MyDrive/Projects/Garbage/garbage_dataset.zip'.
● The zip file is extracted into the '/content/Garbage/original_images' directory.
● Images are loaded using ImageFolder from torchvision.datasets with resizing
transformation applied to ensure uniformity (32x32 pixels).

Class Distribution Visualization:

● The class distribution of the dataset is visualized using a bar plot. The counts of images
in each class are computed using os.listdir and len functions.
● Class names and corresponding image counts are stored in lists for plotting.
● A bar plot is generated using matplotlib.pyplot to visualize the class distribution, with
each bar representing a garbage class and its height corresponding to the number of
images.

Image Preprocessing:
● The convert_scale function is defined to handle image preprocessing tasks for each
class.
● For each garbage class, it creates paths for the original and processed image
directories.
● All image filenames in the original directory are retrieved using os.listdir.
 ● Images are loaded, resized to 32x32 pixels using Image.open and resize, and converted
to grayscale using convert('L').
● Processed grayscale images are saved to the corresponding processed image directory.
● Preprocessing is performed for all images in each class using a loop.

Sample Image Visualization:

● The get_image_paths function retrieves a sample of 5 image file paths from a given
folder path.
● The plot_sample_images function visualizes the sample images in a single row, using
matplotlib.pyplot.
● Sample images are loaded using Image.open and plotted in subplots using plt.imshow.
● The axes are hidden using plt.axis('off'), and the figure is displayed using plt.show().

Usage:
The Garbage Classification Preprocessing module simplifies the dataset preparation process by
automating image loading, resizing, conversion to grayscale, and class distribution visualization.
The code efficiently preprocesses the dataset, making it suitable for garbage classification
tasks. Additionally, the sample image visualization allows users to inspect the quality of the
processed images and gain insights into the variety of data available for training or testing the
classification model.

1. Import the necessary libraries and mount Google Drive to access the dataset.
2. Load the original images, resize them to 32x32 pixels, convert them to grayscale, and save
the processed images in '/content/Garbage/processed_images'.
3. Visualize the class distribution in the dataset using a bar plot to understand the data
distribution across different garbage classes.
4. Obtain a sample of 5 images from each class in both the original and processed datasets for
visual inspection.
5. Display the sample images in rows for each class to better understand the quality and
diversity of the data after preprocessing.

The Garbage Classification Preprocessing module ensures the dataset is adequately prepared
and ready for subsequent steps in the garbage classification process. The image preprocessing
steps enable the model to handle consistent input sizes and simplified feature representations.
Users can use the class distribution visualization to assess dataset balance and identify
potential data augmentation needs. By visualizing sample images, users gain insights into the
dataset's content, ensuring data quality and aiding model selection and design decisions.

Module 1: Air Quality Analysis

This module focuses on analyzing air quality data collected across various states in India. The
goal is to calculate the Air Quality Index (AQI) and gain insights into air pollution trends over
time. The analysis involves several technical details and preprocessing techniques.
Data Loading and Preprocessing:
- Import necessary libraries: NumPy, Pandas, Matplotlib, Seaborn, and Basemap.
- Load air quality data from the "../input/" directory using Pandas.
- Fill missing values in the data with zeros for consistent analysis.

Calculating Individual Pollutant Indices:

- Define functions to calculate individual pollutant indices for SO2, NO2, RSPM, and SPM.
- The indices are computed based on predefined ranges specified by Indian government
standards.

Calculating Air Quality Index (AQI):

- Calculate AQI based on individual pollutant indices for each data point.
- The AQI represents the overall air quality and is determined by the highest value among the
individual pollutant indices.

Visualization of AQI Across India:

- Use the Basemap library to plot a map of India.
- Fetch geographical locations (latitude and longitude) of the states from another dataset.
- Represent AQI values on the map using markers of varying sizes and colors.

Time Series Analysis and Visualization:

- Perform time series analysis on AQI trends over the years.
- Resample data to get monthly average AQI values.
- Use seasonal decomposition to observe patterns, trends, and seasonality in the data.

This air quality analysis involves extensive preprocessing techniques, including data cleaning,
calculating individual pollutant indices, and computing the AQI. The visualization techniques
provide valuable insights into air pollution patterns and trends across India. Policymakers can
use these insights to formulate effective strategies for improving air quality and public health.
The time series analysis helps in identifying seasonal patterns and long-term trends, enabling
better decision-making for environmental management.

Module 1: Pollution Estimation System - Advanced Data Preprocessing

Introduction:
The Pollution Estimation System's Advanced Data Preprocessing module aims to optimize the
dataset for accurate pollution level estimation based on smoke intensity in images. This
sophisticated module incorporates intricate image processing techniques, data augmentation,
and advanced data visualization to enhance the model's performance and robustness.

Dependencies:
- OpenCV (cv2): Utilized for image processing tasks like loading, resizing, and color space
conversion.
- NumPy: For numerical operations and array manipulations.
- Matplotlib.pyplot: Used for plotting class distribution and sample images.
- Skimage (scikit-image): Enables advanced image processing functionalities.

Functionality:

1. Data Loading and Image Resizing:

- Import necessary libraries: OpenCV and NumPy.
- Load images from the dataset directory.
- Resize all images to a consistent size, such as 224x224 pixels, using advanced interpolation
techniques (e.g., Lanczos).
- Apply data normalization to scale pixel values to a range suitable for the model (e.g., [0, 1]).

2. Image Augmentation:
- Implement data augmentation techniques using Skimage to enhance dataset diversity and
robustness.
- Apply random rotations, flips, and brightness adjustments to generate augmented images.
- Save the augmented images in a separate directory to be used during model training.

3. Class Distribution Visualization:

- Calculate the number of images in each class to visualize class distribution.
- Store class names and corresponding image counts in lists for plotting.
- Utilize Matplotlib.pyplot to generate a bar plot, representing each class and its image count.
- This visualization aids in understanding the data distribution across different pollution levels.

4. Image Preprocessing:
- Define complex image preprocessing functions to handle resizing, color space conversion, and
enhancement.
- Use advanced image processing techniques, such as histogram equalization and denoising.
- Implement region of interest (ROI) extraction to focus on relevant image areas containing
smoke.
- Apply edge detection algorithms to emphasize smoke boundaries and features.
- Save the preprocessed images in a separate directory to be used in the pollution level
estimation model.

Usage:
The Advanced Data Preprocessing module significantly optimizes the dataset for accurate and
robust pollution level estimation. The incorporation of complex image processing techniques,
data augmentation, and data visualization enhances the model's ability to handle diverse and
challenging environmental conditions. The advanced image preprocessing ensures that the
model receives meaningful and relevant input representations, resulting in improved estimation
accuracy.
1. Import necessary libraries and load images from the 'dataset' directory.
2. Resize all images to a consistent size (e.g., 224x224 pixels) using advanced interpolation
techniques.
3. Apply data normalization to scale pixel values to a suitable range (e.g., [0, 1]).
4. Implement data augmentation techniques to increase dataset diversity and robustness.
5. Visualize the class distribution using a bar plot to understand data distribution across different
pollution levels.
6. Implement complex image preprocessing functions to handle resizing, color space
conversion, enhancement, ROI extraction, and edge detection.
7. Save the preprocessed images in a separate directory for subsequent use.
8. Obtain a sample of 5 images from each class for visual inspection.
9. Display the sample images along with their augmented versions to assess dataset diversity.

The Advanced Data Preprocessing module significantly enhances the dataset's quality and
prepares it for subsequent steps in the pollution level estimation process. By applying advanced
image processing techniques and data augmentation, the module ensures that the model can
effectively handle various environmental scenarios and make accurate pollution level
predictions. Users can use the class distribution visualization to assess dataset balance and
identify potential data augmentation needs. The visualization of sample images provides
valuable insights into the dataset's diversity and prepares users for potential challenges in
model development.