Medical Imaging AI: Custom CAD System Development

A radiologist misses up to 30% of pathologies per shift — this is standard statistics for tired eyes. An AI assistant designed with medical imaging specifics reduces that figure to 5%. But only if the system is trained on correct data and provides explainable decisions. We develop CAD (Computer-Aided Detection) systems that serve as a second pair of eyes for the physician. We have 12+ years in AI/ML and 25+ projects in medical imaging. Certified solutions are already deployed in clinics. Medical AI development requires attention to data specifics, regulatory compliance, and clinical validation. The cost is estimated individually after auditing your DICOM data.

Why Off-the-Shelf CV Models Don't Fit Medicine

Medical images are fundamentally different from photographs. Class imbalance: pathology occupies <5% of pixels. Small datasets: annotated scans number in the hundreds, not millions. Explainability requirements: the physician needs to know why the model made a diagnosis. Therefore, we use specialized architectures (U-Net, EfficientNet) and explainability tools (Grad-CAM).

How We Solve the Class Imbalance Problem

We use a combination of loss functions: Dice loss + Focal loss. This forces the model to focus on small pathologies. Additionally, we apply augmentations: random affine, elastic deformations, cutout. In practice, the Dice coefficient increases by 0.1–0.15 compared to standard CrossEntropy. This approach yields a 10-15% sensitivity gain on rare pathologies.

Medical Data Specifics

Formats: DICOM — the standard for medical images. Contains patient metadata, acquisition parameters, and serial scans (CT/MRI are stacks of hundreds of slices). It's important to correctly convert pixel values to Hounsfield Units (HU) for CT.

import pydicom import numpy as np import cv2 class DICOMProcessor: def load_series(self, dicom_dir: str) -> np.ndarray: """Load a series of DICOM slices (CT/MRI) into a 3D array""" import os slices = [] for file in sorted(os.listdir(dicom_dir)): if file.endswith('.dcm'): dcm = pydicom.dcmread(os.path.join(dicom_dir, file)) slices.append(dcm) # Sort by slice position slices.sort(key=lambda x: float(x.ImagePositionPatient[2])) # Convert to HU for CT volume = np.stack([self._to_hu(s) for s in slices]) return volume, slices[0] # volume + metadata def _to_hu(self, dcm: pydicom.Dataset) -> np.ndarray: """DICOM pixel data → Hounsfield Units""" pixel_array = dcm.pixel_array.astype(np.float32) slope = float(dcm.RescaleSlope) intercept = float(dcm.RescaleIntercept) return pixel_array * slope + intercept def window_level(self, hu_array: np.ndarray, window: int = 400, level: int = 40) -> np.ndarray: """Windowing for visualizing specific tissues""" low = level - window // 2 high = level + window // 2 clipped = np.clip(hu_array, low, high) return ((clipped - low) / (high - low) * 255).astype(np.uint8) 

How We Ensure Explainability

Each prediction is accompanied by an activation map (Grad-CAM) and a confidence map (probability map). The physician sees not only the label but also the region the model relied on. This is critical for decision-making: the system is an assistant, not a replacement. Additionally, we implement out-of-distribution detection — if a scan is unlike the training data, the system reports low confidence.

Computer-Aided Detection (CAD) System Architecture

import torch import torch.nn as nn import segmentation_models_pytorch as smp class MedicalCADSystem: def __init__(self, config: dict): # Segmentation model for pathologies self.segmentation_model = smp.Unet( encoder_name='efficientnet-b4', encoder_weights='imagenet', in_channels=1, # grayscale for CT/MRI classes=config['num_classes'], activation=None ) # Classifier for verification self.classifier = self._build_classifier(config) # Grad-CAM for explainability self.explainer = GradCAMExplainer(self.classifier) @torch.no_grad() def analyze(self, dicom_slice: np.ndarray) -> dict: tensor = self._preprocess(dicom_slice) # Segmentation seg_logits = self.segmentation_model(tensor) seg_probs = torch.sigmoid(seg_logits).squeeze().numpy() # Classification cls_logits = self.classifier(tensor) cls_probs = torch.softmax(cls_logits, dim=1).squeeze().numpy() # Explainability heatmap grad_cam = self.explainer.generate(tensor, target_class=cls_probs.argmax()) return { 'segmentation_mask': (seg_probs > 0.5).astype(np.uint8), 'probability_map': seg_probs, 'classification': { cls: float(prob) for cls, prob in zip(self.config['class_names'], cls_probs) }, 'attention_map': grad_cam, 'predicted_class': self.config['class_names'][cls_probs.argmax()], 'confidence': float(cls_probs.max()) } 

What Metrics Are Critical for Medical AI?

Typical target: sensitivity ≥ 90% with specificity ≥ 85%. In one project for a clinic, we trained a lung nodule segmentation model on 5,000 CT scans. The Dice coefficient on an external dataset reached 0.89 — 1.5 times higher than a standard U-Net with ImageNet weights.

How to Integrate AI with PACS?

Integration is done through a DICOM gateway: the system subscribes to new studies, receives images, processes them, and sends results back as DICOM SR (structured reports). DICOM Query/Retrieve and HL7 FHIR are supported. This minimizes changes to the clinic's infrastructure — the AI service runs as an additional module.

Requirements for Medical System Development

Validation is done in three stages: internal (train/test with time gap), external (independent dataset from another institution), and clinical (prospective study with physicians). Regulatory requirements vary: EU — CE Class IIa/IIb (MDR 2017/745), US — FDA 510(k) clearance, Russia — Roszdravnadzor and GOST R. Ethical aspects: DICOM tag anonymization, informed consent, audit trail.

What's Included in the Work?

1. Requirements analysis and DICOM data audit.
2. Model architecture development (U-Net, ViT).
3. Training with validation on external datasets.
4. Integration with PACS via DICOM gateway.
5. Documentation for regulators (FDA, CE).
6. Physician training on the system.
7. Post-release support and monitoring.

Comparison with Traditional Methods

Compared to manual analysis, an AI system reduces the time to review a single image from 15 minutes to 30 seconds — a 30x speedup. This saves up to 80% of a radiologist's time and lowers diagnostic costs by reducing repeat studies. Pathology detection accuracy increases by 20-30%, especially at early stages.

Contact us to discuss the requirements for your medical AI system. Get a consultation on architecture and development cost — we'll evaluate your project and propose the optimal solution.