AI & ML

Ensemble Learning for Cancer Risk Prediction: Our CancerGuard AI Approach

How we built a HIPAA-aligned cancer risk prediction system using an ensemble of XGBoost, LightGBM, Random Forest, and Neural Networks — with 69 API endpoints.

🧑‍💻

Harsha Bonthada

Founder & Lead Engineer

January 20, 2026

11 min read

The Challenge

Cancer risk prediction is one of the most impactful applications of machine learning in healthcare. Early detection saves lives — but building a reliable prediction system requires more than just training a single model.

Why Ensemble Learning?

No single ML algorithm performs best across all cancer types and patient demographics. Our approach: combine multiple models and let them vote.

python

class CancerEnsemblePredictor:
    def __init__(self):
        self.models = {
            'xgboost': XGBClassifier(
                n_estimators=500,
                max_depth=6,
                learning_rate=0.01,
                subsample=0.8,
                colsample_bytree=0.8
            ),
            'lightgbm': LGBMClassifier(
                n_estimators=500,
                num_leaves=31,
                learning_rate=0.01,
                feature_fraction=0.8
            ),
            'random_forest': RandomForestClassifier(
                n_estimators=300,
                max_depth=10,
                min_samples_split=5
            ),
            'neural_net': self._build_neural_network()
        }
        self.meta_learner = LogisticRegression()
    
    def _build_neural_network(self):
        model = Sequential([
            Dense(256, activation='relu', input_shape=(feature_count,)),
            BatchNormalization(),
            Dropout(0.3),
            Dense(128, activation='relu'),
            BatchNormalization(),
            Dropout(0.2),
            Dense(64, activation='relu'),
            Dense(1, activation='sigmoid')
        ])
        model.compile(optimizer='adam', loss='binary_crossentropy')
        return model

The Stacking Architecture

We use a two-level stacking approach:

Level 1: Four base models each make independent predictions

Level 2: A meta-learner (Logistic Regression) combines the base predictions

This consistently outperforms any individual model by 3-7% on our validation set.

Data Pipeline

Patient data flows through a rigorous preprocessing pipeline:

Missing Value Imputation — KNN imputer for numerical, mode for categorical

Feature Engineering — BMI calculation, age binning, interaction features

Normalization — StandardScaler for neural network, raw for tree models

Class Balancing — SMOTE for minority class oversampling

API Architecture

The backend exposes 69 REST endpoints organized by role:

Patient Portal (22 endpoints): Risk assessment, history, reports

Hospital Portal (28 endpoints): Patient management, analytics, blood bank

Admin Portal (19 endpoints): System config, model management, audit logs

Blood Donor Geo-Matching

A unique feature is our blood donor geo-matching system. When a patient needs a transfusion:

python

async def find_nearest_donors(
    patient_location: GeoPoint,
    blood_type: str,
    radius_km: float = 25.0,
    limit: int = 10
) -> list[DonorMatch]:
    compatible_types = get_compatible_blood_types(blood_type)
    
    donors = await db.donors.find({
        'blood_type': {'$in': compatible_types},
        'is_available': True,
        'last_donation_date': {'$lt': thirty_days_ago},
        'location': {
            '$nearSphere': {
                '$geometry': patient_location,
                '$maxDistance': radius_km * 1000
            }
        }
    }).limit(limit)
    
    return [DonorMatch(
        donor=d,
        distance=calculate_distance(patient_location, d.location),
        compatibility_score=score_compatibility(blood_type, d.blood_type)
    ) for d in donors]

Results

Model Accuracy: 94.2% on held-out test set

AUC-ROC: 0.967

API Response Time: <200ms for risk prediction

Data Processing: Handles 10K+ patient records

Privacy & Compliance

All patient data is encrypted at rest and in transit. We follow HIPAA guidelines for data handling, with role-based access control and complete audit logging.

Tags:

Healthcare

Machine Learning

Ensemble

Python

FastAPI

AI & ML

12 min read

Building NEXUS AI OS: Architecture of a 13-Agent Local AI System

Deep dive into the architecture behind NEXUS AI OS — how we orchestrate 13+ specialized AI agents running entirely on-device with Ollama, ChromaDB, and a custom IPC bus.

Ollama

Multi-Agent

🧑‍💻

Harsha Bonthada

Mar 1, 2026

AI & ML

9 min read

Vision AI: Active Learning with YOLOv8 on ESP32-CAM

How we built an active learning pipeline that continuously improves YOLOv8 object detection accuracy using ESP32-CAM edge devices.

Harsha Bonthada

Dec 28, 2025

Engineering

10 min read

Local-First Algorithmic Trading with DuckDB and Python

How we built a quantitative trading engine for Indian equities (NSE) that runs entirely on your machine — no cloud, no latency, no subscription fees.

Harsha Bonthada

Dec 1, 2025

Stay in the Loop

Get engineering insights, project updates, and open source news delivered to your inbox.

No spam. Unsubscribe at any time. Read our Privacy Policy.

Back to Blog

AI & ML

Ensemble Learning for Cancer Risk Prediction: Our CancerGuard AI Approach

How we built a HIPAA-aligned cancer risk prediction system using an ensemble of XGBoost, LightGBM, Random Forest, and Neural Networks — with 69 API endpoints.

🧑‍💻

Harsha Bonthada

Founder & Lead Engineer

January 20, 2026

11 min read

The Challenge

Why Ensemble Learning?

No single ML algorithm performs best across all cancer types and patient demographics. Our approach: combine multiple models and let them vote.

python

class CancerEnsemblePredictor:
    def __init__(self):
        self.models = {
            'xgboost': XGBClassifier(
                n_estimators=500,
                max_depth=6,
                learning_rate=0.01,
                subsample=0.8,
                colsample_bytree=0.8
            ),
            'lightgbm': LGBMClassifier(
                n_estimators=500,
                num_leaves=31,
                learning_rate=0.01,
                feature_fraction=0.8
            ),
            'random_forest': RandomForestClassifier(
                n_estimators=300,
                max_depth=10,
                min_samples_split=5
            ),
            'neural_net': self._build_neural_network()
        }
        self.meta_learner = LogisticRegression()
    
    def _build_neural_network(self):
        model = Sequential([
            Dense(256, activation='relu', input_shape=(feature_count,)),
            BatchNormalization(),
            Dropout(0.3),
            Dense(128, activation='relu'),
            BatchNormalization(),
            Dropout(0.2),
            Dense(64, activation='relu'),
            Dense(1, activation='sigmoid')
        ])
        model.compile(optimizer='adam', loss='binary_crossentropy')
        return model

The Stacking Architecture

We use a two-level stacking approach:

Level 1: Four base models each make independent predictions

Level 2: A meta-learner (Logistic Regression) combines the base predictions

This consistently outperforms any individual model by 3-7% on our validation set.

Data Pipeline

Patient data flows through a rigorous preprocessing pipeline:

Missing Value Imputation — KNN imputer for numerical, mode for categorical

Feature Engineering — BMI calculation, age binning, interaction features

Normalization — StandardScaler for neural network, raw for tree models

Class Balancing — SMOTE for minority class oversampling

API Architecture

The backend exposes 69 REST endpoints organized by role:

Patient Portal (22 endpoints): Risk assessment, history, reports

Hospital Portal (28 endpoints): Patient management, analytics, blood bank

Admin Portal (19 endpoints): System config, model management, audit logs

Blood Donor Geo-Matching

A unique feature is our blood donor geo-matching system. When a patient needs a transfusion:

python

async def find_nearest_donors(
    patient_location: GeoPoint,
    blood_type: str,
    radius_km: float = 25.0,
    limit: int = 10
) -> list[DonorMatch]:
    compatible_types = get_compatible_blood_types(blood_type)
    
    donors = await db.donors.find({
        'blood_type': {'$in': compatible_types},
        'is_available': True,
        'last_donation_date': {'$lt': thirty_days_ago},
        'location': {
            '$nearSphere': {
                '$geometry': patient_location,
                '$maxDistance': radius_km * 1000
            }
        }
    }).limit(limit)
    
    return [DonorMatch(
        donor=d,
        distance=calculate_distance(patient_location, d.location),
        compatibility_score=score_compatibility(blood_type, d.blood_type)
    ) for d in donors]

Results

Model Accuracy: 94.2% on held-out test set

AUC-ROC: 0.967

API Response Time: <200ms for risk prediction

Data Processing: Handles 10K+ patient records

Privacy & Compliance

All patient data is encrypted at rest and in transit. We follow HIPAA guidelines for data handling, with role-based access control and complete audit logging.

Tags:

Healthcare

Machine Learning

Ensemble

Python

FastAPI

AI & ML

12 min read

Building NEXUS AI OS: Architecture of a 13-Agent Local AI System

Deep dive into the architecture behind NEXUS AI OS — how we orchestrate 13+ specialized AI agents running entirely on-device with Ollama, ChromaDB, and a custom IPC bus.

Ollama

Multi-Agent

🧑‍💻

Harsha Bonthada

Mar 1, 2026

AI & ML

9 min read