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

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

我正在尝试实现一个能够extract来自数字视网膜图像的血管。我正在与公开可用的驱动数据库 http://www.isi.uu.nl/Research/Databases/DRIVE/（图像为 .tif 格式）。

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

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

Fig1 https://i.stack.imgur.com/0Na8a.jpg

我尝试使用一些功能，例如：tf.extract_image_pathces or 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)

您可以组合使用reshape and 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]])

where 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]])

Where tiles4是形状的 4D 张量[B, H, W, C], and 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], :]