csmp-hub/helacytonuke

HeLaCytoNuc

Overview

HeLaCytoNuc contains 2,676 microscope images of HeLa cells grown in the lab, with masks marking individual nuclei and whole cells. You can use it to train and test models that find these structures.

Nuclei appear in blue and the cells' actin fibres appear in red. The training and validation masks were made with CellProfiler. The test masks were drawn by hand; CellProfiler masks for the same test images are also included.

License: CC BY 4.0. You may use, change and share the data, including commercially, if you credit the creators, keep the license notices and describe your changes.

Files and splits

Split	File	Images	Masks made by	Nuclei	Whole cells
train	train.parquet	1,873	CellProfiler automatic	108,485	108,485
val	val.parquet	535	CellProfiler automatic	19,571	19,571
test	test.parquet	268	Manual	18,588	20,190

The original splits are kept; validation is shortened to val. The extra automatic masks stay with their test images. Keep all test images and both versions of their masks out of training when using this test set for evaluation.

The Parquet files contain the ready-to-use images and masks. The original release also provides larger raw images. License, source and preparation notes are included alongside the Parquet files.

Fields

Each row contains one image and its masks, stored as PNG bytes. The loading example below turns these into NumPy arrays.

Field	Contents
id	Image name, such as helacytonuke_0000
image	Colour image: 520 pixels high × 696 wide, with red, green and blue channels; uint8 values from 0 to 255
inst	Nucleus mask: each nucleus has its own number
inst_cell	Whole-cell mask: each cell has its own number
type	Simple nucleus mask: 1 inside a marked nucleus, 0 elsewhere
pairs	Suggested matches between nucleus and cell numbers; see below
annotation_source	Who made the main masks: cellprofiler or manual
inst_auto, inst_cell_auto	Extra CellProfiler nucleus and cell masks for test images; empty (null) in train/val
source_split	Original split name: train, validation or test
file_name, source_image_id	Original filename and image number

All masks are 520 × 696 pixels. The numbered masks use uint16; type uses uint8. Zero means background, and the original object numbers are kept. A nucleus and its cell may have different numbers—use pairs rather than matching numbers directly.

Labels

The main masks are inst for nuclei and inst_cell for whole cells. A whole-cell mask includes the nucleus. These cell masks come from the source's cytoplasm_masks files and have been kept as supplied. They are not cytoplasm-only masks.

pairs lists 114,733 suggested nucleus-to-cell matches. A match is included only when the nucleus lies completely inside one cell and neither object overlaps any other object in the other mask. These matches were calculated from the masks, not checked by a person. Objects without a match are still included.

The hand-drawn test masks do not always agree about cell and nucleus boundaries, so do not assume every nucleus has a matching cell. The extra automatic test masks use their own object numbers.

There are no cell-type labels. type only marks where the annotated nuclei are.

Download and read a sample

from io import BytesIO

import numpy as np
import polars as pl
from huggingface_hub import hf_hub_download
from PIL import Image

path = hf_hub_download(
    repo_id="csmp-hub/helacytonuke", filename="train.parquet", repo_type="dataset"
)
row = pl.scan_parquet(path).head(1).collect().to_dicts()[0]


def decode_png(data):
    with Image.open(BytesIO(data)) as image:
        return np.array(image)


image = decode_png(row["image"])  # HWC RGB uint8, red=actin, blue=DAPI
nuclei = decode_png(row["inst"]).astype(np.uint16)  # HW nucleus instance IDs
cells = decode_png(row["inst_cell"]).astype(np.uint16)  # HW whole-cell IDs
label_source = row["annotation_source"]  # "cellprofiler" in train/val; "manual" in test

Use val.parquet or test.parquet for another split. On a test row, decode_png(row["inst_auto"]) and decode_png(row["inst_cell_auto"]) read the alternate automatic masks.

Plot examples

Continue from the loading example. The first two rows use automatic training labels; the third uses manual test labels.

import matplotlib.pyplot as plt
from skimage.segmentation import find_boundaries

test_path = hf_hub_download(
    repo_id="csmp-hub/helacytonuke", filename="test.parquet", repo_type="dataset"
)
columns = ["id", "image", "inst", "inst_cell", "annotation_source"]
samples = pl.scan_parquet(path).select(columns).head(2).collect().to_dicts()
samples += pl.scan_parquet(test_path).select(columns).head(1).collect().to_dicts()

fig, axes = plt.subplots(3, 3, figsize=(12, 10))
for row_axes, sample in zip(axes, samples):
    rgb = decode_png(sample["image"])
    row_axes[0].imshow(rgb)
    for ax, key, color in zip(
        row_axes[1:], ["inst", "inst_cell"], [(45, 180, 245), (245, 155, 45)]
    ):
        mask = decode_png(sample[key])
        overlay = rgb.astype(np.float32).copy()
        overlay[mask > 0] = 0.65 * overlay[mask > 0] + 0.35 * np.array(color)
        overlay[find_boundaries(mask, mode="inner")] = color
        ax.imshow(overlay.astype(np.uint8))
    label = f"{sample['id']} · {sample['annotation_source']}"
    row_axes[0].text(0, 1.03, label, transform=row_axes[0].transAxes, fontsize=9)
    for ax in row_axes:
        ax.axis("off")
for ax, title in zip(
    axes[0], ["Fluorescence image", "Nucleus instances", "Whole-cell instances"]
):
    ax.set_title(title, pad=25)
fig.subplots_adjust(
    left=0.02, right=0.98, bottom=0.02, top=0.93, hspace=0.22, wspace=0.03
)
plt.show()

Two examples without the image underneath. Black marks background; bright instance colours distinguish objects, not cell types. Colours do not indicate nucleus-to-cell matches.

from skimage.color import label2rgb

instance_colors = [
    (1, 0.85, 0.2),
    (0.2, 1, 1),
    (1, 0.3, 0.8),
    (0.5, 1, 0.2),
    (0.65, 0.55, 1),
]
mask_samples = samples
mask_samples = [mask_samples[0], mask_samples[-1]]
mask_layers = [("inst", "Nucleus instances"), ("inst_cell", "Whole-cell instances")]
mask_fig, mask_axes = plt.subplots(2, 2, figsize=(6.4, 6))
for row_axes, sample in zip(mask_axes, mask_samples):
    for column, (ax, (key, title)) in enumerate(zip(row_axes, mask_layers)):
        labels = decode_png(sample[key])
        pixels = label2rgb(
            labels, colors=instance_colors, bg_label=0, bg_color=(0, 0, 0)
        )
        ax.imshow(pixels, interpolation="nearest")
        ax.set_axis_off()
    label = sample["id"]
    label += " · " + sample["annotation_source"]
    row_axes[0].text(0, 1.02, label, transform=row_axes[0].transAxes, fontsize=8)
for ax, (_, title) in zip(mask_axes[0], mask_layers):
    ax.set_title(title, fontsize=10, pad=18)
mask_fig.subplots_adjust(
    left=0.01, right=0.99, bottom=0.02, top=0.94, hspace=0.16, wspace=0.03
)
plt.show()

Preparation and validation

Prepared from the original HeLaCytoNuc release, version 1.

The original TIFF images and masks were saved as PNG bytes in Parquet files. Image pixels, mask numbers and split assignments were kept unchanged. Numbered masks now use uint16, and type and pairs were added as described above.

Every saved image and mask was checked against the original, including both versions of the test masks. File checks and further details are recorded in manifest.json and split-audit.json.

Limitations

• These are images of HeLa cells grown in the lab. Results may differ on other cells or tissue images.
• CellProfiler masks can contain mistakes, and hand-drawn nucleus and cell boundaries do not always agree.
• No duplicate or very similar images were found across splits, including after rotation or flipping. However, the source does not identify which images share a well, plate or imaging session. The splits may therefore share experimental conditions.
• There are no tissue-region masks, cell-type labels or measurements of physical pixel size.

License and citation

The dataset is released under CC BY 4.0. When sharing it, credit the creators, link to the source and license, keep the supplied notices, and explain any changes you make. LICENSE contains the full terms; NOTICE.md describes this version's changes.

Please cite:

De, T.; Urbanski, A.; Thangamani, S.; Wyrzykowska, M.; Yakimovich, A. (2024). HeLaCytoNuc: fluorescence microscopy dataset with segmentation masks for cell nuclei and cytoplasm. Version 1. RODARE. doi:10.14278/rodare.3001.

The original description also credits the screening study by Rämö et al. (2014), Simultaneous analysis of large-scale RNAi screens for pathogen entry, and Carpenter et al. (2006), CellProfiler: image analysis software for identifying and quantifying cell phenotypes. Their full references are kept in source-description.txt.