Project Aether's Eye

Autonomous AI System for Astronomical Anomaly Detection

🎯 Project Scope

Build an autonomous AI system that monitors astronomical time-lapse data, detects anomalies using deep learning, prioritizes discoveries, and provides real-time visualization dashboards.

🛠 Technology Stack
TensorFlow
PyTorch
OpenCV
Python
Pandas
Matplotlib
📊 Progress Tracking

Track your development progress through each phase

⏱ Estimated Timeline

Phase 1: 2-3 days
Phase 2: 5-7 days
Phase 3: 4-6 days
Phase 4: 3-5 days
Phase 5: 2-4 days

⚙️
Phase 1: Setup and Data Preparation
The Foundation
The goal of this phase is to set up your development environment and prepare the raw data your AI will learn from.
Environment Setup
Not Started
Create a dedicated project folder and Python virtual environment with all necessary libraries.
Create Project Structure:
mkdir aethers_eye && cd aethers_eye
Virtual Environment:
python -m venv aether_env
source aether_env/bin/activate (Linux/Mac)
aether_env\Scripts\activate (Windows)
Install Dependencies:
pip install tensorflow pytorch opencv-python pandas numpy matplotlib
Source the Data
Not Started
Find and download high-resolution, long-duration time-lapse video of the night sky.
Recommended Sources:
• European Southern Observatory (ESO)
• NASA Goddard
• Hubble Space Telescope Archives
Video Requirements:
• High resolution (1080p minimum)
• Long duration (30+ minutes)
• Clear night sky footage
• Minimal cloud interference
File Formats:
Preferred: .mp4, .avi, .mov
Video-to-Frame Conversion
Not Started
Write a Python script using OpenCV to extract individual frames from your video file.
Script Structure:
• Load video with cv2.VideoCapture()
• Loop through frames with cap.read()
• Save frames as frame_XXXX.jpg
Directory Structure:
data/frames/ - Individual frame images
data/video/ - Original video files
Expected Output:
Hundreds to thousands of sequential frame images ready for processing
🤖
Phase 2: The Sentinel
Anomaly Detection with TensorFlow
In this phase, you'll build the first part of the AI: a system that can spot changes in the sky.
Image Differencing Script
Not Started
Create a script that compares consecutive frames to highlight pixel changes and potential anomalies.
Core Algorithm:
• Load consecutive frames
• Convert to grayscale
• Compute absolute difference
• Apply threshold to filter noise
Key Functions:
cv2.absdiff() - Calculate differences
cv2.threshold() - Filter noise
cv2.findContours() - Detect objects
Create Training Dataset
Not Started
Manually classify detected changes into anomalies and noise to create training data.
Data Organization:
data/training/anomaly/ - Real events
data/training/noise/ - False positives
Target Dataset Size:
• 500+ anomaly examples
• 500+ noise examples
Train Anomaly Filter
Not Started
Build and train a CNN using TensorFlow to distinguish real anomalies from sensor noise.
Model Architecture:
• Convolutional layers for feature extraction
• Pooling layers for dimensionality reduction
• Dense layers for classification
Success Metrics:
• >90% validation accuracy
• Low false positive rate
✨
Phase 3: The Cognitive Core
Prioritization with PyTorch
Now you'll build the "brain" that decides how important an anomaly is.
Feature Extraction
Not Started
Extract quantitative features from detected anomalies for priority scoring.
Key Features to Extract:
• Brightness/intensity
• Object size (area, perimeter)
• Velocity (pixels per frame)
• Direction of movement
Store Features
Not Started
Organize extracted features into structured data format for machine learning.
Data Structure: Use a Pandas DataFrame.
Preprocessing: Normalize feature values.
Export Format: features.csv
Train Prioritization Model
Not Started
Build a PyTorch neural network that assigns priority scores (0.0 to 1.0) to anomalies.
Network Architecture:
• Input layer: Feature vector
• Hidden layers: 2-3 fully connected layers
• Output layer: Single neuron with sigmoid activation
🛰️
Phase 4: Integration and Real-Time Simulation
Bringing It All Together
This is where you assemble all the components into a single, running application.
Build the Main Loop
Not Started
Create a master Python script that simulates real-time processing by reading frames sequentially.
Processing Pipeline:
Load frame → Preprocess → Detect changes → Classify → Extract features → Prioritize → Log results
Chain the Models
Not Started
Integrate all AI components into a seamless processing pipeline.
Data Flow Management: Ensure outputs from one model are correctly formatted as inputs for the next.
Simulate Telescope Tasking
Not Started
Implement alert system that triggers when high-priority anomalies are detected.
Alert Thresholds: Set a priority score threshold (e.g., > 0.9) to trigger an alert.
Alert Action: Print a message to the console, e.g., HIGH PRIORITY ALERT: Tasking telescope...
📊
Phase 5: Visualization Dashboard
Mission Control Interface
The final phase is creating a visual interface to monitor your AI system in real-time.
Create Dashboard Script
Not Started
Build the foundation for a real-time monitoring dashboard using Matplotlib or Plotly.
Technology Options:
• Matplotlib: Static plots, good for basic visualization
• Plotly Dash: Interactive web dashboard
Develop the Visuals
Not Started
Create comprehensive visualization components for monitoring and analysis.
Current Frame Display: Live frame with detected anomalies circled.
High-Priority Events Table: Timestamp, coordinates, priority score.
Analytics Charts: Anomalies over time, priority score distribution.