Create README.md

README.md

@@ -1,11 +1,236 @@
 ---
-title: Deforestation Detection
-emoji: 😻
-colorFrom: green
-colorTo: yellow
+license: apache-2.0
 sdk: docker
-pinned: false
-license: mit
+pinned: true
+short_description: Detect deforestation from satellite imagery.
 ---
+# 🌳 Deforestation Detection using Satellite Imagery
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This project aims to **detect deforestation from satellite images** using a **U-Net deep learning model**. It leverages automated satellite data collection, image segmentation techniques, and Earth Engine + TensorFlow pipelines to help environmental organizations monitor illegal deforestation in near real-time.
+
+<p align="center">
+  <img src="Final Output.png" width="70%"/>
+</p>
+
+---
+
+## 📌 Project Objective
+
+> **Can an automated model built on satellite imagery help environmental organizations monitor illegal deforestation in near real-time?**
+
+We aim to answer this by building a robust deep learning pipeline that:
+- Collects satellite imagery for selected regions and years.
+- Trains a U-Net segmentation model on forest/non-forest (or deforested) labels.
+- Allows users to input coordinates + year and visualize predictions on a Leaflet map.
+
+---
+
+## 🛰️ Data Collection & Preprocessing
+
+We use **Google Earth Engine (GEE)** to fetch Sentinel-2 or Landsat-8 imagery and NDVI indices.
+
+### Data Sources:
+- **Imagery**: Landsat-8 (30m resolution), optionally Sentinel-2 (10m resolution).
+- **Labels**: Derived using NDVI and/or forest loss layers from Global Forest Change dataset.
+
+### Preprocessing:
+- Region-wise time-lapse collection.
+- NDVI-based labeling: Thresholding NDVI to identify vegetation loss.
+- Tiling large images into patches.
+- Saving as `.npy` and `.tfrecord` formats for model training.
+
+---
+
+## 🧠 Model Architecture
+
+The model uses a **U-Net architecture** implemented in **TensorFlow**, designed for image segmentation tasks.
+
+- **Input**: Satellite image patches (RGB or NDVI composite).
+- **Output**: Binary mask indicating deforested areas.
+
+### Features:
+- Batch normalization and dropout regularization
+- Dice coefficient + binary cross-entropy loss
+- Data augmentation (rotation, flipping, contrast)
+
+---
+
+## ⚙️ Training
+
+```bash
+python train.py --epochs 50 --batch_size 16 --data_dir ./data --save_model ./models/unet_deforestation.h5
+
+```
+
+## 📈 Evaluation
+
+The trained model is evaluated on a held-out test set using the following metrics:
+
+- **IoU (Intersection over Union)**: Measures the overlap between predicted deforested area and ground truth.
+- **Dice Coefficient**: Especially useful for imbalanced classes.
+- **Precision & Recall**: To understand false positives and false negatives.
+- **F1 Score**: Harmonic mean of precision and recall.
+
+
+---
+
+## 🌍 Deployment
+
+### Hugging Face Space 🚀  
+Visit: [**Deforestation Detection on Hugging Face**](https://huggingface.co/spaces/ojasrohatgi/Deforestation-Detection)
+
+Features:
+- Interactive Leaflet map to select coordinates
+- Year input to analyze temporal deforestation
+- On-click image fetching and prediction overlay
+- Downloadable prediction masks for offline use
+
+### Backend Logic
+The backend takes user inputs (`lat, lon, year`), queries GEE for imagery, preprocesses it into patches, passes it to the trained U-Net model, and returns a combined prediction image with overlays.
+
+---
+
+## 🧾 Project Structure
+
+```bash
+Deforestation-Detection/
+│
+├── app/                         # Streamlit-based frontend interface
+│   ├── main.py                  # Streamlit UI & user interaction logic
+│   ├── map_component.html       # Leaflet map integration for coordinate input
+│   ├── overlay.py               # Image overlay + visualization helpers
+│   └── utils.py                 # Patching, preprocessing, and GEE interaction
+│
+├── model/                       # Trained model artifacts
+│   └── unet_deforestation.h5    # Final trained U-Net model
+│
+├── earth_engine/                # Scripts for working with GEE
+│   └── export_data.py           # Downloads satellite images + NDVI labels
+│
+├── training/                    # Model architecture and training logic
+│   ├── train.py                 # Model training loop
+│   ├── evaluate.py              # Evaluation script for test data
+│   ├── metrics.py               # IoU, Dice, and other evaluation metrics
+│   └── unet_model.py            # Custom U-Net implementation
+│
+├── data/                        # Data directory (images, masks, TFRecords)
+│   ├── train/                   # Training image and mask patches
+│   ├── val/                     # Validation image and mask patches
+│   └── test/                    # Test image and mask patches
+│
+├── requirements.txt             # Python dependencies
+├── README.md                    # This file
+└── .gitattributes / .gitignore  # GitHub config files
+```
+
+## 🧪 How to Run Locally
+
+### 1. Clone the repository
+
+```bash
+git clone [https://github.com/Ojas-Rohatgi/Deforestation-Detection](https://github.com/Ojas-Rohatgi/Deforestation-Detection)
+cd Deforestation-Detection
+
+```
+
+### 2. Set up a virtual environment
+
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+pip install -r requirements.txt
+
+```
+
+### 3. Prepare data
+
+Ensure you have satellite imagery and labeled NDVI masks stored in the `data/` folder.
+You can generate training data using Earth Engine export scripts in `earth_engine/export_data.py`.
+
+### 4. Train the model
+
+```bash
+python training/train.py --epochs 50 --batch\_size 16 --data\_dir ./data --save\_model ./model/unet\_deforestation.h5
+
+```
+You can configure the number of epochs, batch size, and save path as needed.
+
+### 5. Run the app
+
+```bash
+cd app
+streamlit run main.py
+
+```
+This will launch a web interface where you can:
+
+* Select a region using the interactive Leaflet map
+* Input a year (e.g., 2020)
+* Fetch satellite imagery and get prediction overlays
+
+---
+
+## ☁️ Deployment
+
+This app is live at:
+🔗 [Hugging Face Spaces – ojasrohatgi/Deforestation-Detection](https://huggingface.co/spaces/ojasrohatgi/Deforestation-Detection)
+
+### Features:
+
+* 🌍 Interactive map for selecting location
+* 📅 Year input for time-based analysis
+* 📷 Automatic image fetch via GEE
+* 🧠 Real-time inference with trained U-Net
+* 🖼️ Visual overlay of predictions
+* ⬇️ Option to download the prediction mask
+
+---
+
+## ⚙️ Tech Stack
+
+| Component        | Tools Used                             |
+| ---------------- | -------------------------------------- |
+| Model            | TensorFlow 2.x, Keras, U-Net           |
+| Data Source      | Google Earth Engine (Landsat-8, NDVI) |
+| Frontend         | Flask, Leaflet.js                  |
+| Image Processing | NumPy, OpenCV, Matplotlib, PIL         |
+| Deployment       | Hugging Face Spaces, GitHub            |
+| Output Formats   | PNG masks, NumPy arrays, TFRecords     |
+
+---
+
+## 🚀 Future Roadmap
+
+* [ ] Multi-year change detection (e.g., forest loss between 2015–2023)
+* [ ] Visual heatmaps of deforestation severity
+* [ ] Region-specific fine-tuning for Southeast Asia, Amazon, and Africa
+* [ ] Support for multispectral and SAR imagery
+* [ ] Webhooks/API integration for automated NGO alerts
+
+---
+
+## 🙋‍♂️ Author
+
+**Ojas Rohatgi**
+Final Year B.Tech – Computer Science (Data Science & AI)
+SRM University, Sonepat, Haryana, India
+
+* 🔗 GitHub: [Ojas-Rohatgi](https://github.com/Ojas-Rohatgi)
+* 🔗 Hugging Face: [ojasrohatgi](https://huggingface.co/ojasrohatgi)
+
+---
+
+## 📜 License
+
+This project is licensed under the **MIT License**.
+See the [LICENSE](LICENSE) file for full license text.
+
+---
+
+## ⭐️ Support This Project
+
+If you found this useful:
+
+* 🌟 Star this repository on GitHub
+* 🚀 Share the Hugging Face app with your network
+* 📢 Report issues or suggest improvements in the Issues tab