ValueError: Sequence must have length 2, got 3.

[Frankieljy]

Traceback (most recent call last):
File "/home/ljy0808/anaconda3/envs/monai/lib/python3.7/site-packages/monai/transforms/transform.py", line 90, in apply_transform
return _apply_transform(transform, data, unpack_items)
File "/home/ljy0808/anaconda3/envs/monai/lib/python3.7/site-packages/monai/transforms/transform.py", line 54, in _apply_transform
return transform(parameters)
File "/home/ljy0808/anaconda3/envs/monai/lib/python3.7/site-packages/monai/transforms/croppad/dictionary.py", line 678, in call
box_start, box_end = self.cropper.compute_bounding_box(img=d[self.source_key])
File "/home/ljy0808/anaconda3/envs/monai/lib/python3.7/site-packages/monai/transforms/croppad/array.py", line 840, in compute_bounding_box
spatial_size = np.asarray(compute_divisible_spatial_size(orig_spatial_size.tolist(), k=self.k_divisible))
File "/home/ljy0808/anaconda3/envs/monai/lib/python3.7/site-packages/monai/transforms/utils.py", line 1300, in compute_divisible_spatial_size
k = fall_back_tuple(k, (1,) * len(spatial_shape))
File "/home/ljy0808/anaconda3/envs/monai/lib/python3.7/site-packages/monai/utils/misc.py", line 197, in fall_back_tuple
user = ensure_tuple_rep(user_provided, ndim)
File "/home/ljy0808/anaconda3/envs/monai/lib/python3.7/site-packages/monai/utils/misc.py", line 154, in ensure_tuple_rep
raise ValueError(f"Sequence must have length {dim}, got {len(tup)}.")
ValueError: Sequence must have length 2, got 3.

I debug this and find:
spatial_size = img.shape[1:]
data = img[list(ensure_tuple(channel_indices))] if channel_indices is not None else img
data = select_fn(data).any(0)
ndim = len(data.shape)
margin = ensure_tuple_rep(margin, ndim)
generate_spatial_bounding_box create the ndim which is the shape of data and this problem also find in:generate_spatial_bounding_box looses first dimension #3723
and i try to delete any(0),but make a lot of problems

[KumoLiu]

Hi @Frankieljy, could you please share your code, seems you specify k_divisible with length 3.

[Frankieljy]

following is my code:it base on 3D Brain Tumor Segmentation with Swin UNETR (BraTS 21 Challenge)
import os
import json
import shutil
import tempfile
import time

import matplotlib.pyplot as plt
import numpy as np
import nibabel as nib

from monai.losses import DiceLoss
from monai.inferers import sliding_window_inference
from monai import transforms
from monai.transforms import (
AsDiscrete,
Activations,
)

from monai.config import print_config
from monai.metrics import DiceMetric
from monai.utils.enums import MetricReduction
from monai.networks.nets import SwinUNETR
from monai import data
from monai.data import decollate_batch
from functools import partial

import torch
MONAI_DATA_DIRECTORY='./home/ljy0808/swin'
directory = './home/ljy0808/swin'
root_dir = tempfile.mkdtemp() if directory is None else directory
class AverageMeter(object):
def init(self):
self.reset()

def reset(self):
    self.val = 0
    self.avg = 0
    self.sum = 0
    self.count = 0

def update(self, val, n=1):
    self.val = val
    self.sum += val * n
    self.count += n
    self.avg = np.where(self.count > 0, self.sum / self.count, self.sum)

def datafold_read(datalist, basedir, fold=0, key="training"):

with open(datalist) as f:
    json_data = json.load(f)

json_data = json_data[key]

for d in json_data:
    for k, v in d.items():
        if isinstance(d[k], list):
            d[k] = [os.path.join(basedir, iv) for iv in d[k]]
        elif isinstance(d[k], str):
            d[k] = os.path.join(basedir, d[k]) if len(d[k]) > 0 else d[k]

tr = []
val = []
for d in json_data:
    if "fold" in d and d["fold"] == fold:
        val.append(d)
    else:
        tr.append(d)

return tr, val

def save_checkpoint(model, epoch, filename="model.pt", best_acc=0, dir_add=root_dir):
state_dict = model.state_dict()
save_dict = {"epoch": epoch, "best_acc": best_acc, "state_dict": state_dict}
filename = os.path.join(dir_add, filename)
torch.save(save_dict, filename)
print("Saving checkpoint", filename)

def get_loader(batch_size, data_dir, json_list, fold, roi):
data_dir = data_dir
datalist_json = json_list
train_files, validation_files = datafold_read(
datalist=datalist_json, basedir=data_dir, fold=fold
)
train_transform = transforms.Compose(
[
transforms.LoadImaged(keys=["image", "label"]),
transforms.ConvertToMultiChannelBasedOnBratsClassesd(keys="label"),
transforms.CropForegroundd(
keys=["image", "label"],
source_key="image",
k_divisible=[roi[0], roi[1], roi[2]],
),
transforms.RandSpatialCropd(
keys=["image", "label"],
roi_size=[roi[0], roi[1], roi[2]],
random_size=False,
),
transforms.RandFlipd(keys=["image", "label"], prob=0.5, spatial_axis=0),
transforms.RandFlipd(keys=["image", "label"], prob=0.5, spatial_axis=1),
transforms.RandFlipd(keys=["image", "label"], prob=0.5, spatial_axis=2),
transforms.NormalizeIntensityd(
keys="image", nonzero=True, channel_wise=True
),
transforms.RandScaleIntensityd(keys="image", factors=0.1, prob=1.0),
transforms.RandShiftIntensityd(keys="image", offsets=0.1, prob=1.0),
transforms.ToTensord(keys=['image','label']),
]
)
val_transform = transforms.Compose(
[
transforms.LoadImaged(keys=["image", "label"]),
transforms.ConvertToMultiChannelBasedOnBratsClassesd(keys="label"),
transforms.NormalizeIntensityd(
keys="image", nonzero=True, channel_wise=True
),
]
)

train_ds = data.Dataset(data=train_files, transform=train_transform)

train_loader = data.DataLoader(
    train_ds,
    batch_size=batch_size,
    shuffle=True,
    num_workers=0,
    pin_memory=True,
)
val_ds = data.Dataset(data=validation_files, transform=val_transform)
val_loader = data.DataLoader(
    val_ds,
    batch_size=1,
    shuffle=False,
    num_workers=0,
    pin_memory=True,
)

return train_loader, val_loader

data_dir = "/home/ljy0808/swin/data"
json_list = "/home/ljy0808/swin/dataset.json"
roi = (64, 64,32)
batch_size = 6
sw_batch_size = 1
fold = 1
infer_overlap = 0.5
max_epochs = 100
val_every = 10
train_loader, val_loader = get_loader(batch_size, data_dir, json_list, fold, roi)

os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

model = SwinUNETR(
img_size=roi,
in_channels=4,
out_channels=1,
feature_size=48,
drop_rate=0.0,
attn_drop_rate=0.0,
dropout_path_rate=0.0,
use_checkpoint=True,
spatial_dims=3,
).to(device)

torch.backends.cudnn.benchmark = True
dice_loss = DiceLoss(to_onehot_y=False, sigmoid=True)
post_sigmoid = Activations(sigmoid=True)
post_pred = AsDiscrete(argmax=False, threshold=0.5)
dice_acc = DiceMetric(
include_background=True, reduction=MetricReduction.MEAN_BATCH, get_not_nans=True
)
model_inferer = partial(
sliding_window_inference,
roi_size=[roi[0], roi[1], roi[2]],
sw_batch_size=sw_batch_size,
predictor=model,
overlap=infer_overlap,
)

optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-5)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=max_epochs)
def train_epoch(model, loader, optimizer, epoch, loss_func):
model.train()
start_time = time.time()
run_loss = AverageMeter()
for idx, batch_data in enumerate(loader):
data, target = batch_data["image"].to(device), batch_data["label"].to(device)
logits = model(data)
loss = loss_func(logits, target)
loss.backward()
optimizer.step()
run_loss.update(loss.item(), n=batch_size)
print(
"Epoch {}/{} {}/{}".format(epoch, max_epochs, idx, len(loader)),
"loss: {:.4f}".format(run_loss.avg),
"time {:.2f}s".format(time.time() - start_time),
)
start_time = time.time()
return run_loss.avg

def val_epoch(
model,
loader,
epoch,
acc_func,
model_inferer=None,
post_sigmoid=None,
post_pred=None,
):
model.eval()
start_time = time.time()
run_acc = AverageMeter()

with torch.no_grad():
    for idx, batch_data in enumerate(loader):
        data, target = batch_data["image"].to(device), batch_data["label"].to(
            device
        )
        logits = model_inferer(data)
        val_labels_list = decollate_batch(target)
        val_outputs_list = decollate_batch(logits)
        val_output_convert = [
            post_pred(post_sigmoid(val_pred_tensor))
            for val_pred_tensor in val_outputs_list
        ]
        acc_func.reset()
        acc_func(y_pred=val_output_convert, y=val_labels_list)
        acc, not_nans = acc_func.aggregate()
        run_acc.update(acc.cpu().numpy(), n=not_nans.cpu().numpy())
        Dice_TC = run_acc.avg[0]
        Dice_WT = run_acc.avg[1]
        Dice_ET = run_acc.avg[2]
        print(
            "Val {}/{} {}/{}".format(epoch, max_epochs, idx, len(loader)),
            ", Dice_TC:",
            Dice_TC,
            ", Dice_WT:",
            Dice_WT,
            ", Dice_ET:",
            Dice_ET,
            ", time {:.2f}s".format(time.time() - start_time),
        )
        start_time = time.time()

return run_acc.avg

def trainer(
model,
train_loader,
val_loader,
optimizer,
loss_func,
acc_func,
scheduler,
model_inferer=None,
start_epoch=0,
post_sigmoid=None,
post_pred=None,
):

val_acc_max = 0.0
Dices_TC = []
Dices_WT = []
Dices_ET = []
Dices_avg = []
loss_epochs = []
trains_epoch = []
for epoch in range(start_epoch, max_epochs):
    print(time.ctime(), "Epoch:", epoch)
    epoch_time = time.time()
    train_loss = train_epoch(
        model,
        train_loader,
        optimizer,
        epoch=epoch,
        loss_func=loss_func,
    )
    print(
        "Final training  {}/{}".format(epoch, max_epochs - 1),
        "loss: {:.4f}".format(train_loss),
        "time {:.2f}s".format(time.time() - epoch_time),
    )

    if (epoch + 1) % val_every == 0 or epoch == 0:
        loss_epochs.append(train_loss)
        trains_epoch.append(int(epoch))
        epoch_time = time.time()
        val_acc = val_epoch(
            model,
            val_loader,
            epoch=epoch,
            acc_func=acc_func,
            model_inferer=model_inferer,
            post_sigmoid=post_sigmoid,
            post_pred=post_pred,
        )
        Dice_TC = val_acc[0]
        Dice_WT = val_acc[1]
        Dice_ET = val_acc[2]
        val_avg_acc = np.mean(val_acc)
        print(
            "Final validation stats {}/{}".format(epoch, max_epochs - 1),
            ", Dice_TC:",
            Dice_TC,
            ", Dice_WT:",
            Dice_WT,
            ", Dice_ET:",
            Dice_ET,
            ", Dice_Avg:",
            val_avg_acc,
            ", time {:.2f}s".format(time.time() - epoch_time),
        )
        Dices_TC.append(Dice_TC)
        Dices_WT.append(Dice_WT)
        Dices_ET.append(Dice_ET)
        Dices_avg.append(val_avg_acc)
        if val_avg_acc > val_acc_max:
            print("new best ({:.6f} --> {:.6f}). ".format(val_acc_max, val_avg_acc))
            val_acc_max = val_avg_acc
            save_checkpoint(
                model,
                epoch,
                best_acc=val_acc_max,
            )
        scheduler.step()
print("Training Finished !, Best Accuracy: ", val_acc_max)
return (
    val_acc_max,
    Dices_TC,
    Dices_WT,
    Dices_ET,
    Dices_avg,
    loss_epochs,
    trains_epoch,
)

start_epoch = 0

(
val_acc_max,
Dices_TC,
Dices_WT,
Dices_ET,
Dices_avg,
loss_epochs,
trains_epoch,
) = trainer(
model=model,
train_loader=train_loader,
val_loader=val_loader,
optimizer=optimizer,
loss_func=dice_loss,
acc_func=dice_acc,
scheduler=scheduler,
model_inferer=model_inferer,
start_epoch=start_epoch,
post_sigmoid=post_sigmoid,
post_pred=post_pred,
)

[KumoLiu]

Hi @Frankieljy, you set k_divisible with length 3 here. Could you please check your image and label's shape to make sure they are channel first? If not try to add EnsureChannelFirst after LoadImage. You can refer to this tutorial.

transforms.CropForegroundd(
keys=["image", "label"],
source_key="image",
k_divisible=[roi[0], roi[1], roi[2]],
),
transforms.RandSpatialCropd(
keys=["image", "label"],
roi_size=[roi[0], roi[1], roi[2]],
random_size=False,
),

Hope it can help you, thanks!