Tensorflow 入门 - 将图像分割为子图像

Question

这是我第一次使用卷积神经网络和 Tensorflow。

我正在尝试实现一个能够从数字视网膜图像中提取血管的卷积神经网络。我正在使用公开可用的Drive 数据库（图像为 .tif 格式）。

由于我的图像非常大，我的想法是将它们分成大小为 28x28x1 的子图像（“1”是绿色通道，是我唯一需要的）。为了创建训练集，我从每个图像中迭代随机裁剪 28x28 批次，并在此集上训练网络。

现在，我想在数据库中的一张大图像上测试我训练过的网络（也就是说，我想将网络应用于完整的眼睛）。由于我的网络是在大小为 28x28 的子图像上进行训练的，因此想法是将眼睛分成“n”个子图像，将它们传递给网络，重新组装它们并显示结果，如图 1 所示：

图。1

我尝试使用一些函数，例如： tf.extract_image_pathces或tf.train.batch，但我想知道执行此操作的正确方法是什么。

下面是我的代码片段。我陷入困境的功能是split_image(image)

import numpy
import os
import random

from PIL import Image
import tensorflow as tf

BATCH_WIDTH = 28;
BATCH_HEIGHT = 28;

NUM_TRIALS = 10;

class Drive:
    def __init__(self,train):
        self.train = train

class Dataset:
    def __init__(self, inputs, labels):
        self.inputs = inputs
        self.labels = labels
        self.current_batch = 0

    def next_batch(self):
        batch = self.inputs[self.current_batch], self.labels[self.current_batch]
        self.current_batch = (self.current_batch + 1) % len(self.inputs)
        return batch


#counts the number of black pixel in the batch
def mostlyBlack(image):
    pixels = image.getdata()
    black_thresh = 50
    nblack = 0
    for pixel in pixels:
        if pixel < black_thresh:
            nblack += 1

    return nblack / float(len(pixels)) > 0.5

#crop the image starting from a random point
def cropImage(image, label):
    width  = image.size[0]
    height = image.size[1]
    x = random.randrange(0, width - BATCH_WIDTH)
    y = random.randrange(0, height - BATCH_HEIGHT)
    image = image.crop((x, y, x + BATCH_WIDTH, y + BATCH_HEIGHT)).split()[1]
    label = label.crop((x, y, x + BATCH_WIDTH, y + BATCH_HEIGHT)).split()[0]
    return image, label

def split_image(image):

    ksizes_ = [1, BATCH_WIDTH, BATCH_HEIGHT, 1]
    strides_ = [1, BATCH_WIDTH, BATCH_HEIGHT, 1]

    input = numpy.array(image.split()[1])
    #input = tf.reshape((input), [image.size[0], image.size[1]])

    #input = tf.train.batch([input],batch_size=1)
    split = tf.extract_image_patches(input, padding='VALID', ksizes=ksizes_, strides=strides_, rates=[1,28,28,1], name="asdk")

#creates NUM_TRIALS images from a dataset
def create_dataset(images_path, label_path):
    files = os.listdir(images_path)
    label_files = os.listdir(label_path)

    images = [];
    labels = [];
    t = 0
    while t < NUM_TRIALS:
        index = random.randrange(0, len(files))
        if files[index].endswith(".tif"):
            image_filename = images_path + files[index]
            label_filename = label_path  + label_files[index]
            image = Image.open(image_filename)
            label = Image.open(label_filename)
            image, label = cropImage(image, label)
            if not mostlyBlack(image):
                #images.append(tf.convert_to_tensor(numpy.array(image)))
                #labels.append(tf.convert_to_tensor(numpy.array(label)))
                images.append(numpy.array(image))
                labels.append(numpy.array(label))

                t+=1

    image = Image.open(images_path + files[1])
    split_image(image)

    train = Dataset(images, labels)
    return Drive(train)

Answer 1

reshape您可以使用和调用的组合transpose将图像切割成图块，而无需使用循环：

def split_image(image3, tile_size):
    image_shape = tf.shape(image3)
    tile_rows = tf.reshape(image3, [image_shape[0], -1, tile_size[1], image_shape[2]])
    serial_tiles = tf.transpose(tile_rows, [1, 0, 2, 3])
    return tf.reshape(serial_tiles, [-1, tile_size[1], tile_size[0], image_shape[2]])

其中image3是 3 维张量（例如图像），是指定图块大小的tile_size一对值。[H, W]输出是形状为 的张量[B, H, W, C]。在你的情况下，调用将是：

tiles = split_image(image, [28, 28])

产生形状为 的张量[B, 28, 28, 1]。您还可以通过反向执行以下操作从图块重新组合原始图像：

def unsplit_image(tiles4, image_shape):
    tile_width = tf.shape(tiles4)[1]
    serialized_tiles = tf.reshape(tiles4, [-1, image_shape[0], tile_width, image_shape[2]])
    rowwise_tiles = tf.transpose(serialized_tiles, [1, 0, 2, 3])
    return tf.reshape(rowwise_tiles, [image_shape[0], image_shape[1], image_shape[2]])

其中tiles4是形状 的 4D 张量[B, H, W, C]，image_shape是原始图像的形状。在您的情况下，调用可能是：

image = unsplit_image(tiles, tf.shape(image))

请注意，这仅在图像大小可被图块大小整除时才有效。如果不是这种情况，您需要将图像填充到最接近的图块大小的倍数：

def pad_image_to_tile_multiple(image3, tile_size, padding="CONSTANT"):
    imagesize = tf.shape(image3)[0:2]
    padding_ = tf.to_int32(tf.ceil(imagesize / tile_size)) * tile_size - imagesize
    return tf.pad(image3, [[0, padding_[0]], [0, padding_[1]], [0, 0]], padding)

您可以这样称呼：

image = pad_image_to_tile_multiple(image, [28,28])

然后在从图块中重新组装图像后，通过拼接去除 paddig：

image = image[0:original_size[0], 0:original_size[1], :]