Preparing Microscopy Images for AI Cell Analysis

This guide walks you through preparing microscopy images for AI-based cell analysis, covering everything from acquisition settings to final dataset formatting. You’ll learn the essential steps to ensure your images are clean, consistent, and ready for training or inference with deep learning models. By the end, you’ll have a reproducible workflow that minimizes common pitfalls and maximizes the quality of your AI results.

What You’ll Need

Raw microscopy images (TIFF, CZI, ND2, or similar formats)
Image viewing software (ImageJ/Fiji, QuPath, or napari)
Image processing tools (Fiji with plugins, Python with scikit-image, or CellProfiler)
A computer with sufficient RAM and GPU (for deep learning)
Basic familiarity with your AI framework (e.g., TensorFlow, PyTorch, or a pre-built tool like Cellpose)
Optional: annotation tools (e.g., LabelImg, napari’s annotation widgets)

Step-by-Step

Review acquisition settings. Before processing, check how the images were captured. Note the bit depth (8, 16, or 32-bit), channels, magnification, and any binning. If possible, avoid over-saturation and ensure the dynamic range covers the signal of interest. If you’re acquiring new images, use the same settings across the entire experiment for consistency.
Convert to a standard format. If your files are in proprietary formats (like .czi or .nd2), convert them to TIFF or PNG using Fiji or Bio-Formats. Use 16-bit TIFF for most fluorescence images to preserve dynamic range. For brightfield or phase contrast, 8-bit PNG is often sufficient. Batch convert using a script or the Fiji macro recorder.
Correct illumination artifacts. Apply flat-field correction if you have a reference image (e.g., an empty field). In Fiji, use the Process > Math > Divide function to divide your image by the flat-field. Alternatively, use background subtraction (e.g., rolling ball radius) to remove uneven illumination. This step is critical for quantitative analysis.
Remove noise. Apply a mild Gaussian blur (sigma 1-2) or a median filter to reduce noise. For low-light images, consider using a denoising algorithm like Non-Local Means (in Fiji: Process > Noise > Despeckle or the NL-Means plugin). Avoid aggressive filtering that removes fine details needed for cell boundary detection.
Normalize intensity across images. If you have multiple images from different sessions, normalize the intensity values. One common method is to use the percentile-based normalization: set the 0.1th percentile to 0 and the 99.9th percentile to 1 (for 16-bit, scale to 65535). In Fiji, use Process > Enhance Contrast with the “Normalize” option, or use a Python script with scikit-image’s exposure.rescale_intensity.
Crop and resize consistently. If you plan to use a deep learning model, resize all images to the same dimensions (e.g., 512×512 or 1024×1024 pixels). Use bilinear or bicubic interpolation for downsampling, but avoid upsampling if possible. Crop out any annotations, scale bars, or text that might confuse the AI.
Split channels. For multi-channel images, decide whether to keep channels separate or merge them. For cell segmentation, you might use a single channel (e.g., nuclear stain). For classification, you might need all channels. Save each channel as a separate grayscale image or as a multi-channel TIFF with consistent channel order.
Create annotations (if needed). For supervised learning, you need ground truth labels. Use an annotation tool to draw masks or bounding boxes around cells. For segmentation, create binary masks where the cell pixels are white (255) and background is black (0). Save annotations as PNG files with the same filename as the original image but with a suffix like _mask.
Split into training/validation/test sets. Divide your dataset into three subsets: typically 70% training, 15% validation, and 15% test. Ensure that images from the same biological replicate or well are not split across sets to avoid data leakage. Use a random split with a fixed seed for reproducibility.
Data augmentation (optional but recommended). Increase the diversity of your training set with augmentations like rotation (90°, 180°, 270°), flipping, slight scaling, and small translations. For fluorescence images, avoid intensity augmentations that might change the biological signal. Use libraries like imgaug or Albumentations.
Export in a model-friendly format. For most frameworks, save images as PNG or TIFF in a folder structure like train/images/ and train/masks/. If using a pre-trained model like Cellpose, you can directly use the GUI to load and train on your folder. For custom models, create a CSV or JSON file mapping image paths to labels.
Verify and test. Before training, run a quick sanity check: load a few images and masks into your AI framework and ensure they are aligned and have the correct dimensions. Test the model on a single image to see if the output makes sense. If not, revisit the normalization or annotation steps.

Common Mistakes

Inconsistent normalization: Using different normalization parameters for different images can make the AI learn intensity differences that are not biologically relevant.
Ignoring metadata: Forgetting to record pixel size (µm/pixel) can lead to incorrect size-based filtering in downstream analysis.
Oversaturating images: Clipping highlights during conversion loses information and can cause the AI to miss bright cells.
Using 8-bit for quantitative fluorescence: 8-bit has only 256 intensity levels, which is too coarse for measuring subtle changes in expression.
Not separating channels correctly: If you merge channels incorrectly, the AI might use the wrong color as the signal.
Skipping quality control: Failing to visually inspect the final dataset can lead to mislabeled images or artifacts that ruin training.

Tips

Always keep a backup of the raw, unprocessed images. Processing is destructive, and you may need to redo it with different parameters.
Use a consistent naming convention for files, such as experiment_well_condition_rep1.tif. This helps with debugging and avoids mix-ups.
For large datasets, use a script to automate the preprocessing steps. Fiji macros and Python scripts are both excellent choices.
If you are using a pre-trained model, match the input size and normalization to what the model expects. For example, Cellpose expects 2D grayscale images with values between 0 and 255.
Document every step you take, including software versions and parameters. This is essential for reproducibility and for writing methods sections in papers.
When annotating, have two people independently label a subset of images to check inter-annotator agreement.

Troubleshooting

Images appear black after normalization: Check if your image has a very low dynamic range. Use a histogram to see the min and max values. If the image is mostly zeros, you may have applied the wrong flat-field or background subtraction.
AI model performs poorly on test images: Revisit your training/validation split. Ensure that the test set is from a different batch or condition if possible. Also, check for data leakage (e.g., duplicate images).
Masks are misaligned with cells: This usually happens if you resized images and masks separately. Always apply the same geometric transformations to both. In Python, use the same interpolation method (e.g., nearest neighbor for masks).
Out of memory errors during training: Reduce the image size or use a smaller batch size. Also, consider using a patch-based approach where you train on random crops of the image.
Cells are not detected because they are too faint: Increase the exposure time during acquisition (if possible) or use a more sensitive detector. In post-processing, avoid over-aggressive background subtraction.
Model detects background artifacts as cells: Make sure your annotations exclude debris and out-of-focus objects. Use a size filter in your post-processing to remove objects smaller than a typical cell.

Frequently Asked Questions

What is the best file format for AI training?

TIFF is recommended for 16-bit images because it preserves dynamic range without lossy compression. PNG is acceptable for 8-bit images. Avoid JPEG as it introduces compression artifacts.

Should I use 8-bit or 16-bit images?

For most deep learning models, 8-bit is sufficient if you are only doing segmentation or classification. However, if you plan to quantify intensity, use 16-bit to avoid losing information.

How many images do I need for training?

It depends on the complexity of the task. For simple segmentation, a few hundred images may suffice. For complex phenotypes, you may need thousands. Start with a small set and see if the model overfits; if it does, add more images or use augmentation.

Can I use a pre-trained model instead of training from scratch?

Yes, tools like Cellpose, StarDist, and U-Net with pre-trained weights can be fine-tuned on your data. This is often faster and requires fewer images than training from scratch.

How do I handle 3D image stacks?

You can either process each slice as a 2D image or use a 3D model. For 3D, ensure your masks are also 3D. Many tools like Cellpose support 3D, but they require more memory.

What do I do if my images have different resolutions?

Resample all images to the same pixel size (e.g., 0.5 µm/pixel) before resizing. This ensures that the AI learns features at a consistent scale. Use the metadata to calculate the resampling factor.

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.

More cards in this drawer

The whole Numbers and Powers drawer →