Image chirurgicale et image de segmentation [^ 1] Image de segmentation brute

4. Répartition des données

Cet ensemble de données détermine les images (vidéos) à utiliser pour la formation, la validation et les tests. Les détails peuvent être trouvés dans un fichier appelé splits.txt dans l'ensemble de données. Par conséquent, le groupe divisé adopte le contenu de splits.txt et décrit le chemin du fichier de l'image chirurgicale et de l'image de segmentation de chaque groupe et leur correspondance dans le fichier csv avec le code suivant.

import os
from collections import defaultdict
import pandas as pd


#Créez un fichier csv qui décrit la correspondance entre les images et les étiquettes
def make_csv(fpath, dirlist):
    #Examiner le chemin du fichier de l'image d'entraînement
    dataset = defaultdict(list)
    for dir in dirlist:
        filelist = sorted(os.listdir(f'CaDIS/{dir}/Images'))
        dataset['filename'] += list(map(lambda x: f'{dir}/Images/{x}', filelist))
        filelist = sorted(os.listdir(f'CaDIS/{dir}/Labels'))
        dataset['label'] += list(map(lambda x: f'{dir}/Labels/{x}', filelist))

    #Enregistrer en tant que fichier csv
    dataset = pd.DataFrame(dataset)
    dataset.to_csv(fpath, index=False)



#Dossier vidéo des données d'entraînement
train_dir = ['Video01', 'Video03', 'Video04', 'Video06', 'Video08', 'Video09',
             'Video10', 'Video11', 'Video13', 'Video14', 'Video15', 'Video17',
             'Video18', 'Video20', 'Video21', 'Video22', 'Video23', 'Video24',
             'Video25']

#Dossier vidéo des données de vérification
val_dir = ['Video05', 'Video07', 'Video16']

#Dossier vidéo des données de test
test_dir = ['Video02', 'Video12', 'Video19']


#Créez un fichier csv qui décrit la correspondance entre l'image des données d'entraînement et l'étiquette
make_csv('train.csv', train_dir)

#Créez un fichier csv qui décrit la correspondance entre l'image des données de vérification et l'étiquette
make_csv('val.csv', val_dir)

#Créez un fichier csv qui décrit la correspondance entre l'image des données d'entraînement et l'étiquette
make_csv('test.csv', test_dir)

Le fichier csv contenant les chemins d'accès aux fichiers pour les données d'entraînement, de vérification et de test est dans ce format.

5. Construction et apprentissage de modèles

Tout d'abord, importez la bibliothèque que vous souhaitez utiliser.

import dataclasses
import math
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
from tensorflow.keras.callbacks import EarlyStopping
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, MaxPool2D, UpSampling2D
from tensorflow.keras.layers import Conv2D, BatchNormalization, Activation
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import categorical_crossentropy
from tensorflow.keras.utils import Sequence
import cv2

Ensuite, décrivez les paramètres et ainsi de suite.

directory = 'CaDIS' #Dossier dans lequel les images sont stockées
df_train = pd.read_csv('train.csv') #DataFrame avec informations sur les données d'entraînement
df_validation = pd.read_csv('val.csv') #DataFrame avec informations de données de validation
image_size = (224, 224) #Taille de l'image d'entrée
classes = 36 #Nombre de classes de classification
batch_size = 32 #Taille du lot
epochs = 300 #Nombre d'époques
loss = cce_dice_loss #Fonction de perte
optimizer = Adam(lr=0.001, amsgrad=True) #Fonction d'optimisation
metrics = dice_coeff #Méthode d'évaluation
#ImageDataGenerator Paramètres d'amplification d'image
aug_params = {'rotation_range': 5,
              'width_shift_range': 0.05,
              'height_shift_range': 0.05,
              'shear_range': 0.1,
              'zoom_range': 0.05,
              'horizontal_flip': True,
              'vertical_flip': True}

Ce qui suit est appliqué comme processus de rappel pendant l'apprentissage.

# val_Enregistrer le modèle uniquement lorsque la perte est minimisée
mc_cb = ModelCheckpoint('model_weights.h5',
                        monitor='val_loss', verbose=1,
                        save_best_only=True, mode='min')
#Lorsque l'apprentissage stagne, le taux d'apprentissage est de 0.Double
rl_cb = ReduceLROnPlateau(monitor='loss', factor=0.2, patience=3,
                          verbose=1, mode='auto',
                          min_delta=0.0001, cooldown=0, min_lr=0)
#Si l'apprentissage ne progresse pas, l'apprentissage sera interrompu de force
es_cb = EarlyStopping(monitor='loss', min_delta=0,
                      patience=5, verbose=1, mode='auto')

Génère un générateur de données de formation et de validation. Utilisez ʻImageDataGeneratorpour l'expansion des données. De plus, cette fois, nous utiliseronsSequence` pour créer des données de mini-lots.

La fonction __getitem__ est la partie qui crée spécifiquement un mini-lot. L'image d'entrée est traitée selon la procédure suivante.

1. Chargez l'image
2. Redimensionner à la taille d'image d'entrée spécifiée
3. Convertir en type flottant
4. Effectuer le traitement d'expansion des données
5. Divisez la valeur par 255 et normalisez-la à 0-1

Le traitement de l'image de segmentation est effectué selon la procédure suivante.

1. Chargez l'image
2. Redimensionner à la taille d'image d'entrée spécifiée
3. Convertir en type flottant
4. Effectuer le traitement d'expansion des données
5. Créez une image dans laquelle les pixels de la classe 0 sont 1 et 0 sinon, une image dans laquelle les pixels de la classe 1 sont 1 et 0 sinon ... (pour le nombre de classes) et connectez-les dans le sens du canal. Créer un tableau de tailles (verticales, horizontales, nombre de classes)

#Générateur de données
@dataclasses.dataclass
class TrainSequence(Sequence):
    directory: str #Dossier dans lequel les images sont stockées
    df: pd.DataFrame #DataFrame avec informations sur les données
    image_size: tuple #Taille de l'image d'entrée
    classes: int #Nombre de classes de classification
    batch_size: int #Taille du lot
    aug_params: dict #ImageDataGenerator Paramètres d'amplification d'image

    def __post_init__(self):
        self.df_index = list(self.df.index)
        self.train_datagen = ImageDataGenerator(**self.aug_params)

    def __len__(self):
        return math.ceil(len(self.df_index) / self.batch_size)

    def __getitem__(self, idx):
        batch_x = self.df_index[idx * self.batch_size:(idx+1) * self.batch_size]

        x = []
        y = []
        for i in batch_x:
            rand = np.random.randint(0, int(1e9))
            #Image d'entrée
            img = cv2.imread(f'{self.directory}/{self.df.at[i, "filename"]}')
            img = cv2.resize(img, self.image_size, interpolation=cv2.INTER_LANCZOS4)
            img = np.array(img, dtype=np.float32)
            img = self.train_datagen.random_transform(img, seed=rand)
            img *= 1./255
            x.append(img)

            #Image de segmentation
            img = cv2.imread(f'{self.directory}/{self.df.at[i, "label"]}', cv2.IMREAD_GRAYSCALE)
            img = cv2.resize(img, self.image_size, interpolation=cv2.INTER_LANCZOS4)
            img = np.array(img, dtype=np.float32)
            img = np.reshape(img, (self.image_size[0], self.image_size[1], 1))
            img = self.train_datagen.random_transform(img, seed=rand)
            img = np.reshape(img, (self.image_size[0], self.image_size[1]))
            seg = []
            for label in range(self.classes):
                seg.append(img == label)
            seg = np.array(seg, np.float32)
            seg = seg.transpose(1, 2, 0)
            y.append(seg)

        x = np.array(x)
        y = np.array(y)


        return x, y

#Générer un générateur
##Générateur de données d'entraînement
train_generator = TrainSequence(directory=directory, df=df_train,
                                image_size=image_size, classes=classes,
                                batch_size=batch_size, aug_params=aug_params)
step_size_train = len(train_generator)
##Générateur de données de validation
validation_generator = TrainSequence(directory=directory, df=df_validation,
                                     image_size=image_size, classes=classes,
                                     batch_size=batch_size, aug_params={})
step_size_validation = len(validation_generator)

Dernière fois Construit SegNet avec la structure du CNN simple à 10 couches créé excluant toutes les connexions en tant qu'encodeur et la structure des encodeurs dans l'ordre inverse en tant que décodeur. Faire. Veuillez vous référer à ici pour l'explication de SegNet.

# SegNet(8 couches d'encodeur, 8 couches de décodeur)Construire
def cnn(input_shape, classes):
    #La taille de l'image d'entrée doit être un multiple de 32
    assert input_shape[0]%32 == 0, 'Input size must be a multiple of 32.'
    assert input_shape[1]%32 == 0, 'Input size must be a multiple of 32.'

    #encodeur
    ##Couche d'entrée
    inputs = Input(shape=(input_shape[0], input_shape[1], 3))

    ##1ère couche
    x = Conv2D(32, (3, 3), padding='same', kernel_initializer='he_normal')(inputs)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)
    x = MaxPool2D(pool_size=(2, 2))(x)

    ##2ème couche
    x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)
    x = MaxPool2D(pool_size=(2, 2))(x)

    ##3e couche
    x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)
    x = MaxPool2D(pool_size=(2, 2))(x)

    ##4ème couche
    x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)
    x = MaxPool2D(pool_size=(2, 2))(x)

    ##5ème et 6ème couches
    x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)
    x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)
    x = MaxPool2D(pool_size=(2, 2))(x)

    ##7ème et 8ème couches
    x = Conv2D(1024, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)
    x = Conv2D(1024, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)

    #Décodeur
    ##1ère couche
    x = Conv2D(1024, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)

    ##2ème et 3ème couches
    x = UpSampling2D(size=(2, 2))(x)
    x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)
    x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)

    ##4ème couche
    x = UpSampling2D(size=(2, 2))(x)
    x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)

    ##5ème couche
    x = UpSampling2D(size=(2, 2))(x)
    x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)

    ##6ème couche
    x = UpSampling2D(size=(2, 2))(x)
    x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)

    ##7ème et 8ème couches
    x = UpSampling2D(size=(2, 2))(x)
    x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    x = Conv2D(classes, (1, 1), strides=(1, 1), padding='same', kernel_initializer='he_normal')(x)
    outputs = Activation('softmax')(x)


    return Model(inputs=inputs, outputs=outputs)

#Construction de réseau
model = cnn(image_size, classes)
model.summary()
model.compile(loss=loss, optimizer=optimizer, metrics=[metrics])

Le reste est identique à Dernière fois. Entraînez-vous et enregistrez la courbe d'apprentissage.

#Apprentissage
history = model.fit_generator(
    train_generator, steps_per_epoch=step_size_train,
    epochs=epochs, verbose=1, callbacks=[mc_cb, rl_cb, es_cb],
    validation_data=validation_generator,
    validation_steps=step_size_validation,
    workers=3)

#Dessinez et enregistrez un graphique de la courbe d'apprentissage
def plot_history(history):
    fig, (axL, axR) = plt.subplots(ncols=2, figsize=(10, 4))

    # [la gauche]Graphique sur les métriques
    L_title = 'Dice_coeff_vs_Epoch'
    axL.plot(history.history['dice_coeff'])
    axL.plot(history.history['val_dice_coeff'])
    axL.grid(True)
    axL.set_title(L_title)
    axL.set_ylabel('dice_coeff')
    axL.set_xlabel('epoch')
    axL.legend(['train', 'test'], loc='upper left')

    # [Côté droit]Graphique sur la perte
    R_title = "Loss_vs_Epoch"
    axR.plot(history.history['loss'])
    axR.plot(history.history['val_loss'])
    axR.grid(True)
    axR.set_title(R_title)
    axR.set_ylabel('loss')
    axR.set_xlabel('epoch')
    axR.legend(['train', 'test'], loc='upper left')

    #Enregistrer le graphique en tant qu'image
    fig.savefig('history.jpg')
    plt.close()

#Sauvegarder la courbe d'apprentissage
plot_history(history)

Les résultats d'apprentissage sont les suivants.

6. Évaluation

L'évaluation est effectuée par IoU moyen pour chaque classe et IoU moyen qui est la moyenne d'entre eux. Le calcul a été fait avec le code suivant.

Importation supplémentaire.

from collections import defaultdict

L'inférence et l'évaluation sont effectuées selon la procédure suivante.

1. Chargez l'image
2. Redimensionner à la taille d'image d'entrée spécifiée
3. Convertissez en type flottant et normalisez la valeur de 0 à 1
4. Créez un tableau de taille de lot 1
5. Inférer et obtenir l'image de segmentation
6. Restaurez la taille de l'image de segmentation à sa taille d'origine
7. Calculer l'IoU pour chaque image et chaque classe
8. Calculer l'IoU moyen pour chaque classe

    directory = 'CaDIS' #Dossier dans lequel les images sont stockées
    df_test = pd.read_csv('test.csv') #DataFrame avec informations sur les données de test
    image_size = (224, 224) #Taille de l'image d'entrée
    classes = 36 #Nombre de classes de classification


    #Construction de réseau
    model = cnn(image_size, classes)
    model.summary()
    model.load_weights('model_weights.h5')


    #inférence
    dict_iou = defaultdict(list)
    for i in tqdm(range(len(df_test)), desc='predict'):
        img = cv2.imread(f'{directory}/{df_test.at[i, "filename"]}')
        height, width = img.shape[:2]
        img = cv2.resize(img, image_size, interpolation=cv2.INTER_LANCZOS4)
        img = np.array(img, dtype=np.float32)
        img *= 1./255
        img = np.expand_dims(img, axis=0)
        label = cv2.imread(f'{directory}/{df_test.at[i, "label"]}', cv2.IMREAD_GRAYSCALE)

        pred = model.predict(img)[0]
        pred = cv2.resize(pred, (width, height), interpolation=cv2.INTER_LANCZOS4)

        ##Calcul IoU
        pred = np.argmax(pred, axis=2)
        for j in range(classes):
            y_pred = np.array(pred == j, dtype=np.int)
            y_true = np.array(label == j, dtype=np.int)
            tp = sum(sum(np.logical_and(y_pred, y_true)))
            other = sum(sum(np.logical_or(y_pred, y_true)))
            if other != 0:
                dict_iou[j].append(tp/other)

    # average IoU
    for i in range(classes):
        if i in dict_iou:
            dict_iou[i] = sum(dict_iou[i]) / len(dict_iou[i])
        else:
            dict_iou[i] = -1
    print('average IoU', dict_iou)

Voici les résultats de l'évaluation. De plus, Io U moyen était de 15,0%. D'après l'article [^ 1], VGG est de 20,61%, donc je pense que c'est le cas.

7. Résumé

Dans cet article, nous avons effectué une segmentation sémantique de l'ensemble de données de segmentation de la chirurgie de la cataracte [^ 1] publié par Digital Surgery Ltd. en utilisant SegNet avec 8 couches chacune pour l'encodeur et le décodeur. Selon l'article [^ 1], il semble que 52,66% seront obtenus avec PSPNet, donc à l'avenir, sur la base de ce résultat, je viserai des performances identiques ou meilleures tout en incorporant les dernières méthodes telles que la structure du réseau et la méthode d'expansion des données.