torch.sizeの出力がおかしい

Question

画像データを読み込んで表示させるプログラムです。
機械学習用にデータを読み込みたいです。
画像はうまく出力されるのですが、x.shapeがおかしいです。
プログラムを実行すると、画像の出力とともにtorch.sizeなどが端末に表示されます。
3というのはどこにも定義していないのですが、、
データそのものがおかしいですかね？画像はtiffファイルを８枚重ねています。(3次元)input画像はRGB（３チャンネル）、output画像は白黒（１チャンネル）
バッチサイズは１
Input,Targetの画像はそれぞれ44枚。合計で88枚。
モデルはUNet

現在の表示 　　　 理想
torch.Size([1, 8, 256, 256, 3])　　　→[1, 8, 256, 256]
tensor(0.) tensor(1.)
torch.Size([8, 256, 256])
tensor([0, 1])
torch.Size([1, 1, 8, 256, 256, 3]) 　　→[1, 1, 88, 256, 256]
tensor(0.) tensor(1.)
torch.Size([1, 8, 256, 256]) 　　→[1,88,256,256]
tensor([0, 1]) 　　　　　　　　　　→[0, 1, 2]

# Imports
import pathlib

import albumentations
import numpy as np
import torch
from torch.utils.data import DataLoader

from customdatasets import SegmentationDataSet3
from transformations import (
    ComposeDouble,
    normalize_01,
    AlbuSeg3d,
    FunctionWrapperDouble,
    create_dense_target,
)

#add
from sklearn.model_selection import train_test_split
from unet import UNet
from trainer import Trainer
from skimage.transform import resize


# root directory
#root = pathlib.Path.cwd() / "Microtubules3D"
root = pathlib.Path.cwd() / "Cow3D"


def get_filenames_of_path(path: pathlib.Path, ext: str = "*"):
    """Returns a list of files in a directory/path. Uses pathlib."""
    filenames = [file for file in path.glob(ext) if file.is_file()]
    return filenames


# input and target files
inputs = get_filenames_of_path(root / "Input")
targets = get_filenames_of_path(root / "Target")

#add1
# pre-transformations
pre_transforms = ComposeDouble(
    [
        FunctionWrapperDouble(
            resize, input=True, target=False, output_shape=(128, 128, 128, 1)
        ),
        FunctionWrapperDouble(
            resize,
            input=False,
            target=True,
            output_shape=(128, 128, 128, 1),
            order=0,
            anti_aliasing=False,
            preserve_range=True,
        ),
    ]
)


# training transformations and augmentations
# example how to properly resize and use AlbuSeg3d
# please note that the input is grayscale and the channel dimension of size 1 is added
# also note that the AlbuSeg3d currently only works with input that does not have a C dim!
transforms_training = ComposeDouble(
    [
        # FunctionWrapperDouble(resize, input=True, target=False, output_shape=(16, 100, 100)),
        # FunctionWrapperDouble(resize, input=False, target=True, output_shape=(16, 100, 100), order=0, anti_aliasing=False, preserve_range=True),
        # AlbuSeg3d(albumentations.HorizontalFlip(p=0.5)),
        # AlbuSeg3d(albumentations.VerticalFlip(p=0.5)),
        # AlbuSeg3d(albumentations.Rotate(p=0.5)),
        AlbuSeg3d(albumentations.RandomRotate90(p=0.5)),
        FunctionWrapperDouble(create_dense_target, input=False, target=True),
        FunctionWrapperDouble(np.expand_dims, axis=0),
        # RandomFlip(ndim_spatial=3),
        FunctionWrapperDouble(normalize_01),
    ]
)

#add2
# validation transformations
transforms_validation = ComposeDouble(
    [
        FunctionWrapperDouble(
            resize, input=True, target=False, output_shape=(128, 128, 128, 1)
        ),
        FunctionWrapperDouble(
            resize,
            input=False,
            target=True,
            output_shape=(128, 128, 128, 1),
            order=0,
            anti_aliasing=False,
            preserve_range=True,
        ),
        FunctionWrapperDouble(create_dense_target, input=False, target=True),
        FunctionWrapperDouble(
            np.moveaxis, input=True, target=False, source=-1, destination=0
        ),
        FunctionWrapperDouble(normalize_01),
    ]
)

# random seed
random_seed = 42

#add3
# split dataset into training set and validation set
train_size = 0.8  # 80:20 split
inputs_train, inputs_valid = train_test_split(
    inputs, random_state=random_seed, train_size=train_size, shuffle=True
)
targets_train, targets_valid = train_test_split(
    targets, random_state=random_seed, train_size=train_size, shuffle=True
)


# dataset training
dataset_train = SegmentationDataSet3(
    inputs=inputs,
    targets=targets,
    transform=transforms_training,
    use_cache=False,
    pre_transform=None,
)

#データの数によってdataset_train[]を変化させる　もとはdataset_train[1]
x, y = dataset_train[1]
print(x.shape)
print(x.min(), x.max())
print(y.shape)
print(torch.unique(y))

#add4
# dataset validation
dataset_valid = SegmentationDataSet3(
    inputs=inputs_valid,
    targets=targets_valid,
    transform=transforms_validation,
    use_cache=True,
    pre_transform=pre_transforms,
)

# dataloader training
dataloader_training = DataLoader(
    dataset=dataset_train,
    batch_size=1,
    # batch_size of 2 won't work because the depth dimension is different between the 2 samples
    shuffle=True,
)


#add5
dataloader_validation = DataLoader(
    dataset=dataset_train,
    batch_size=1,
    # batch_size of 2 won't work because the depth dimension is different between the 2 samples
    shuffle=True,
)


batch = next(iter(dataloader_training))
x, y = batch
print(x.shape)
print(x.min(), x.max())
print(y.shape)
print(torch.unique(y))

# create DatasetViewer instances
from visual import DatasetViewer

dataset_viewer_training = DatasetViewer(dataset_train)
dataset_viewer_training.napari()  # navigate with 'n' for next and 'b' for back

# model
model = UNet(
    in_channels=3,
    #in_channels=1,
    out_channels=1,
    #out_channels=3,
    n_blocks=4,
    start_filters=32,
    activation="relu",
    normalization="batch",
    conv_mode="same",
    dim=3,
).to(device)

class SegmentationDataSet3(data.Dataset):
    """Image segmentation dataset with caching, pretransforms and multiprocessing."""

    def __init__(
        self,
        inputs: list,
        targets: list,
        transform=None,
        use_cache=False,
        pre_transform=None,
    ):
        self.inputs = inputs
        self.targets = targets
        self.transform = transform
        self.inputs_dtype = torch.float32
        self.targets_dtype = torch.long
        self.use_cache = use_cache
        self.pre_transform = pre_transform

        if self.use_cache:
            from itertools import repeat
            from multiprocessing import Pool

            with Pool() as pool:
                self.cached_data = pool.starmap(
                    self.read_images, zip(inputs, targets, repeat(self.pre_transform))
                )

    def __len__(self):
        return len(self.inputs)

    def __getitem__(self, index: int):
        if self.use_cache:
            x, y = self.cached_data[index]
        else:
            # Select the sample
            input_ID = self.inputs[index]
            target_ID = self.targets[index]

            # Load input and target
            x, y = imread(str(input_ID)), imread(str(target_ID))

        # Preprocessing
        if self.transform is not None:
            x, y = self.transform(x, y)

        # Typecasting
        x, y = torch.from_numpy(x).type(self.inputs_dtype), torch.from_numpy(y).type(
            self.targets_dtype
        )

        return x, y

    @staticmethod
    def read_images(inp, tar, pre_transform):
        inp, tar = imread(str(inp)), imread(str(tar))
        if pre_transform:
            inp, tar = pre_transform(inp, tar)
        return inp, tar

Comments

[HRCo4]

バッチサイズが1に対して画像を8枚重ねているとはどういうことでしょうか？
torch の入力は [batch, channel, height, width] となるはずですので、[1, 3, 256, 256] を1エポックで8回行うという認識でいます。

[tiroha]

8枚の画像を１つのファイルにマージしているということです。
つまり、８ページの画像が１つの.tiffファイルになっているということです。

[HRCo4]

であれば、バッチサイズは1（＝Datasetから読み込む画像は1枚）、入力画像は8枚となりネットワークへの入力は [8, 3, 256, 256] となるべきかと思います。
"現在の表示"の出力がどの地点のものなのかがわからないのでなんともですが、理想の最初が [1, 8, 256, 256] となっているのは、RGBで画像を読み込むが、ネットワークへはグレースケールしてから入力するということでしょうか？

[tiroha]

いえ。input画像はそのままRGBで読み込み、マスク画像が白黒、予測画像も白黒です。

[tiroha]

UNetの畳み込みを行うときはinput_channel=3, out_channel=1です。

[HRCo4]

x.shape（=inputのshape）なので [1, 8, 256, 256, 3] となるのは当然です。バッチサイズは1で画像1枚に8つの画像がついており、RGBの3chあるということなので。
`from customdatasets import SegmentationDataSet3` の Dataset でどのように画像ロードしているかで shape が変わるかと思います。
あと、out_channel が1ということはクラスタリング数は1ということでしょうか？セグメンテーションは自作やSegnetあたりしか触ったことがくUNetは試したことがないため詳しいことはわかりませんが、普通は最後に softmax を行い、出力channelがクラス数になると思います。（ex.道路画像で"車"と"それ以外"としてもそれだけで2クラスなのでout_channelが2となるはず）

自分が想定しているのは以下の形です。
x.shape(=inputのshape)を[8, 3, 256, 256]（=[1バッチの画像枚数, ch数[RGB], 高さ, 幅]）
y.shape(=maksのshape)を[8, N, 256, 256]（＝[1バッチの画像枚数, クラスタリング数, 高さ, 幅]）

[tiroha]

セグメンテーションは対象：１（白）、それ以外：０（黒）という感じです。
自身のデータセットは牛：１、それ以外：０
にしています。

[HRCo4]

0,1 による判別であれば softmax ではなく sigmoid あたりかな。

Dataset をざっくり見てみましたが、
x, y = imread(str(input_ID)), imread(str(target_ID))
ここで x がおそらく [8, 256, 256, 3]（=[1tiff画像8枚, 幅, 高さ, (RGB)ch数]）となっています。
その後、
x, y = self.transform(x, y) で FunctionWrapperDouble(np.expand_dims, axis=0) によって [1, 8, 256, 256, 3] になっています。
この形が UNet の入力に適切なのかどうかといわれると UNet を触っていないので何ともですが、一般的ではないとは思います。

[tiroha]

そうですね。
恐らく、[1,3,8,256,256]みたいにチャネル数が前に来ると思います。

Answer 1

FunctionWrapperDouble(np.expand_dims, axis=0),
この部分を変更する