Inspiration
This project was inspired by two strong motivations. First, my desire to truly learn how AI models are built, trained, and deployed — not just using AI tools, but understanding the full pipeline from dataset preparation to real inference APIs.
Second, and more importantly, the healthcare reality in my country, Colombia. Public healthcare systems are often overloaded, and access to specialists in small towns and rural areas is limited. Many people must travel long distances just to attend a medical appointment, which creates both economic and logistical burdens.
Appointments with specialists can take months, and delays can worsen conditions that could benefit from earlier screening. I wanted to explore how an AI-based eye image analyzer could support early detection and help reduce unnecessary specialist visits. This is not only a local issue — many developing regions face similar challenges — which makes scalable AI screening tools meaningful.
What it does
AI Eye Detection — Dual Model Classifier analyzes eye images using deep learning models and returns probability-based predictions for possible eye conditions.
The system provides two modes:
Quick Scan Mode — fast general screening model
Specialist Mode — more detailed classification model
Users can upload or capture an eye image through the web interface. The backend processes the image and returns class probabilities and confidence percentages for each condition detected.
It is designed as an AI-assisted screening tool, not a medical diagnosis system.
How we built it
The project was built using a dual-model AI architecture connected to a modern web interface.
Frontend
- Angular standalone
- Angular Material UI
- Browser camera capture
- Guided circular overlay for eye framing
- Image upload support
- Result visualization cards
Backend
- FastAPI inference server
- TensorFlow / Keras models
- SavedModel loaded using TFSMLayer
- NumPy + Pillow preprocessing pipeline
The models were trained using the Google Colab service with strong performance metrics:
- Quick Scan model: 95.6% accuracy
- Specialist model: 92.8% accuracy
Challenges we ran into
- Obtaining and cleaning the data for the training models.
- Since I don’t have access to high-performance local hardware for model training, I leveraged Google Colab’s free GPU environment to train and validate the models. This required careful optimization of training time, dataset size, and checkpoints, and taught me how to work efficiently with limited compute resources.
- Successfully exporting and loading saved TensorFlow models.
- The model's accuracy is sensitive to lighting and framing.
A key limitation is that the models perform best when only a well-lit eye is visible, which required user interface guidance and test images.
Accomplishments that we're proud of
- Successfully trained and deployed two AI eye classification models
- Built a complete frontend-to-AI inference pipeline
- Implemented dual-model selection in real time
- Achieved full probability percentage outputs per class
- Delivered a working AI medical screening prototype end-to-end
- Completed full stack integration under hackathon time constraints
What we learned
The biggest lesson was that in AI projects, dataset quality matters more than code complexity. This was surprising and impactful.
Model performance depends heavily on:
- Data quality
- Label accuracy
- Lighting consistency
- Image framing
- Dataset realism
What's next for AI Eye Detection — Dual Model Classifier
- Larger and more diverse training datasets
- Adding new classes to detect more eye conditions
- Automatic eye region detection before classification
- Better camera capture optimization
- Model performance benchmarking
- Clinical validation datasets
- Guided capture quality scoring
The long-term vision is an AI-assisted screening tool that can support healthcare systems where specialist access is limited.
Built With
- angular.js
- colab
- drive
- javascript
- kaggle
- python
- roboflow
- typescript
Log in or sign up for Devpost to join the conversation.