Или необыкновенные свойства обычной U-net.
Одной из самых жутких проблем для любого любителя, как и для профессионала в data science является качество разметки. Качество разметки способно погубить самую толковую и красивую идею.
Но не всё оказалось так плохо и вашему вниманию предлагается, как и всегда в моих постах, красивая идея с кодами и примером.
Будем учить сеть находить круг в квадратной картинке.
Т.е у нас есть квадрат, заполненный случайными точками с заранее заданными параметрами распределения и там же круг, но уже с точками из другого распределения. Создадим для обучения также маску обучающую и маску истинную.
И так у нас есть картинка с кругом, маска для обучения, явно не совпадающая с картинкой, и точная маска. Вот пример картинок.
Для экспериментов возьмем ту же самую, очень хорошо изученную U-net.
import numpy as np import matplotlib.pyplot as plt %matplotlib inline import math from tqdm import tqdm_notebook, tqdm import tensorflow as tf import keras as keras from keras import Model from keras.models import load_model from keras.optimizers import Adam from keras.layers import Input, Conv2D, Conv2DTranspose, MaxPooling2D, concatenate, Dropout from keras.losses import binary_crossentropy from keras.layers.core import Activation from keras import backend as K from keras.utils.generic_utils import get_custom_objects from tqdm import tqdm_notebook from math import sqrt
w_size = 128 w2_size = w_size // 2 RR = int(w2_size * 0.5) def next_pair(k): delta = np.random.uniform(-10,10) circle = np.zeros((w_size, w_size,1), dtype='int') circle_mask = np.zeros((w_size, w_size), dtype='int') R = RR - (np.random.random_sample()*10) r_x = np.random.random_sample()*(RR//2) # - R//4 r_y = np.random.random_sample()*(RR//2) # - R//4 for i in range(w_size): for j in range(w_size): r = sqrt(float((i - w2_size - r_x)*(i - w2_size - r_x) + (j - w2_size - r_y)*(j - w2_size - r_y))) # if r < (R + np.random.uniform(-20,20)): if r < R + delta: circle_mask[i,j] = 1 if r < R: circle[i,j,0] = 1 img_l = np.random.sample((w_size, w_size, 1))*0.5 img_h = np.random.sample((w_size, w_size, 1))*0.5 + 0.5 img = img_h.copy() img[circle>0] = img_l[circle > 0] msk = np.zeros((w_size, w_size, 1), dtype='float32') msk[circle_mask>0] = 1. # красим пиксели маски эллипса return img, msk, circle
Создаем картинки, маски и истинные, точные маски:
train_num = 2048 from joblib import Parallel, delayed train = np.array(Parallel(n_jobs=4)(delayed(next_pair)(k) for k in range(train_num))) train_x = train[:,0,:,:,:] train_y = train[:,1,:,:,:] train_r = train[:,2,:,:,:] # true mask
Немного модифицируем сеть, DICE точнее указывает совпадение масок:
def dice_coef(y_true, y_pred): smooth = 1. y_true_f = K.flatten(y_true) y_pred_f = K.flatten(y_pred) intersection = y_true_f * y_pred_f score = (2. * K.sum(intersection) + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth) return score get_custom_objects().update({'dice_coef': dice_coef }) def build_model(input_layer, start_neurons): conv1 = Conv2D(start_neurons*1,(3,3),activation="relu", padding="same")(input_layer) conv1 = Conv2D(start_neurons*1,(3,3),activation="relu", padding="same")(conv1) pool1 = MaxPooling2D((2, 2))(conv1) pool1 = Dropout(0.25)(pool1) conv2 = Conv2D(start_neurons*2,(3,3),activation="relu", padding="same")(pool1) conv2 = Conv2D(start_neurons*2,(3,3),activation="relu", padding="same")(conv2) pool2 = MaxPooling2D((2, 2))(conv2) pool2 = Dropout(0.5)(pool2) conv3 = Conv2D(start_neurons*4,(3,3),activation="relu", padding="same")(pool2) conv3 = Conv2D(start_neurons*4,(3,3),activation="relu", padding="same")(conv3) pool3 = MaxPooling2D((2, 2))(conv3) pool3 = Dropout(0.5)(pool3) conv4 = Conv2D(start_neurons*8,(3,3),activation="relu", padding="same")(pool3) conv4 = Conv2D(start_neurons*8,(3,3),activation="relu", padding="same")(conv4) pool4 = MaxPooling2D((2, 2))(conv4) pool4 = Dropout(0.5)(pool4) # Middle convm = Conv2D(start_neurons*16,(3,3),activation="relu", padding="same")(pool4) convm = Conv2D(start_neurons*16,(3,3),activation="relu", padding="same")(convm) deconv4 = Conv2DTranspose(start_neurons * 8, (3, 3), strides=(2, 2), padding="same")(convm) uconv4 = concatenate([deconv4, conv4]) uconv4 = Dropout(0.5)(uconv4) uconv4 = Conv2D(start_neurons*8,(3,3),activation="relu", padding="same")(uconv4) uconv4 = Conv2D(start_neurons*8,(3,3),activation="relu", padding="same")(uconv4) deconv3 = Conv2DTranspose(start_neurons*4,(3,3),strides=(2, 2), padding="same")(uconv4) uconv3 = concatenate([deconv3, conv3]) uconv3 = Dropout(0.5)(uconv3) uconv3 = Conv2D(start_neurons*4,(3,3),activation="relu", padding="same")(uconv3) uconv3 = Conv2D(start_neurons*4,(3,3),activation="relu", padding="same")(uconv3) deconv2 = Conv2DTranspose(start_neurons*2,(3,3),strides=(2, 2), padding="same")(uconv3) uconv2 = concatenate([deconv2, conv2]) uconv2 = Dropout(0.5)(uconv2) uconv2 = Conv2D(start_neurons*2,(3,3),activation="relu", padding="same")(uconv2) uconv2 = Conv2D(start_neurons*2,(3,3),activation="relu", padding="same")(uconv2) deconv1 = Conv2DTranspose(start_neurons*1,(3,3),strides=(2, 2), padding="same")(uconv2) uconv1 = concatenate([deconv1, conv1]) uconv1 = Dropout(0.5)(uconv1) uconv1 = Conv2D(start_neurons*1,(3,3),activation="relu", padding="same")(uconv1) uconv1 = Conv2D(start_neurons*1,(3,3),activation="relu", padding="same")(uconv1) uncov1 = Dropout(0.5)(uconv1) # output_layer = Conv2D(1,(1,1), padding="same", activation="sigmoid")(uconv1) output_layer = Conv2D(1,(1,1), padding="same", activation="sigmoid")(uconv1) return output_layer input_layer = Input((w_size, w_size, 1)) output_layer = build_model(input_layer, 16) model = Model(input_layer, output_layer) model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3), loss=tf.keras.losses.BinaryCrossentropy(), metrics=['dice_coef']) history = model.fit(train_x, train_y ,batch_size=16 ,epochs=10 ,verbose=2 ,validation_split=0.2 ,use_multiprocessing=True )
Результат не очень. Сеть отлично справляется с распознаванием областей при точной разметке. Но если разметка плохая и велика ошибка от реальной разметки, то и точность нашей сети будет не идеальной, всего 0.75. Кого-то наверно это устраивает, кому-то мало.
Epoch 1/10 103/103 - 3s - loss: 0.2875 - dice_coef: 0.4463 - val_loss: 0.1805 - val_dice_coef: 0.6473 Epoch 2/10 103/103 - 3s - loss: 0.1296 - dice_coef: 0.7414 - val_loss: 0.1174 - val_dice_coef: 0.7337 Epoch 3/10 103/103 - 3s - loss: 0.1162 - dice_coef: 0.7539 - val_loss: 0.1132 - val_dice_coef: 0.7482 Epoch 4/10 103/103 - 3s - loss: 0.1112 - dice_coef: 0.7603 - val_loss: 0.1091 - val_dice_coef: 0.7657 Epoch 5/10 103/103 - 3s - loss: 0.1085 - dice_coef: 0.7617 - val_loss: 0.1331 - val_dice_coef: 0.7584 Epoch 6/10 103/103 - 3s - loss: 0.1088 - dice_coef: 0.7605 - val_loss: 0.1080 - val_dice_coef: 0.7599 Epoch 7/10 103/103 - 3s - loss: 0.1064 - dice_coef: 0.7635 - val_loss: 0.1067 - val_dice_coef: 0.7573 Epoch 8/10 103/103 - 3s - loss: 0.1062 - dice_coef: 0.7638 - val_loss: 0.1069 - val_dice_coef: 0.7587 Epoch 9/10 103/103 - 3s - loss: 0.1054 - dice_coef: 0.7649 - val_loss: 0.1068 - val_dice_coef: 0.7617 Epoch 10/10 103/103 - 3s - loss: 0.1058 - dice_coef: 0.7644 - val_loss: 0.1087 - val_dice_coef: 0.7616 1
Но нас интересует другое, гораздо более интересное явление. Сравним нашу разметку и полученное предсказание.
pred = model.predict(train_x) dice_coef(train_y.astype('float32'), pred).numpy() 0.7675821 dice_coef(train_r.astype('float32'), pred).numpy() 0.819669
И тут вдруг вот оно - оказывается полученное предсказание меньше отличается от истинной разметки, нежели использованная нами искаженная разметка. Отлично.
Мы теперь выбрасываем нашу первоначальную разметку за ненадобностью и проводим новый сеанс обучения, уже используя полученное предсказание pred как новую маску.
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3), loss=tf.keras.losses.BinaryCrossentropy(), metrics=['dice_coef']) history = model.fit(train_x, pred>0.5 ,batch_size=16 ,epochs=10 ,verbose=2 ,validation_split=0.2 ,use_multiprocessing=True )
Epoch 1/10 103/103 - 3s - loss: 0.0045 - dice_coef: 0.9899 - val_loss: 0.0021 - val_dice_coef: 0.9944 Epoch 2/10 103/103 - 3s - loss: 0.0030 - dice_coef: 0.9933 - val_loss: 0.0017 - val_dice_coef: 0.9953 Epoch 3/10 103/103 - 3s - loss: 0.0027 - dice_coef: 0.9941 - val_loss: 0.0016 - val_dice_coef: 0.9958 Epoch 4/10 103/103 - 3s - loss: 0.0024 - dice_coef: 0.9946 - val_loss: 0.0016 - val_dice_coef: 0.9960 Epoch 5/10 103/103 - 3s - loss: 0.0022 - dice_coef: 0.9951 - val_loss: 0.0014 - val_dice_coef: 0.9963 Epoch 6/10 103/103 - 3s - loss: 0.0021 - dice_coef: 0.9953 - val_loss: 0.0014 - val_dice_coef: 0.9963 Epoch 7/10 103/103 - 3s - loss: 0.0021 - dice_coef: 0.9955 - val_loss: 0.0014 - val_dice_coef: 0.9965 Epoch 8/10 103/103 - 3s - loss: 0.0020 - dice_coef: 0.9957 - val_loss: 0.0014 - val_dice_coef: 0.9965 Epoch 9/10 103/103 - 3s - loss: 0.0019 - dice_coef: 0.9958 - val_loss: 0.0013 - val_dice_coef: 0.9967 Epoch 10/10 103/103 - 3s - loss: 0.0019 - dice_coef: 0.9959 - val_loss: 0.0014 - val_dice_coef: 0.9965
И тут получаем просто фантастический результат - точность больше 0.99!
А конкретно достигаем dice_coeff 0.9919946, имея на руках дрянную разметку в начале.
pred_1 = model.predict(train_x) dice_coef(train_r.astype('float32'), pred_1).numpy() 0.9919946
Итак мы получили следующее: у нас есть картинки для сегментации и некачественная разметка.
Проявив реальный интеллект, смекалку и немного искусственного интеллекта, мы восстановили реальную, точную разметку, из данной нам некачественной. Т.е. наше предсказание сегментации всё-таки достигло нужной и приемлемой точности.
Конечно же, у нас игрушечный датасет, простая U-net и мы не пытаемся решать глобальные задачи и быть там, где не хотим быть.
Но идея полезная, нужная и пригодится может всем.
Главное, это поверить, что и на вашем датасете, с вашей сетью этот эффект сохранится ))
