liver_tumor_segmentation_v3.ipynb

{"cells":[{"cell_type":"code","execution_count":1,"metadata":{"execution":{"iopub.execute_input":"2023-11-08T21:59:24.632775Z","iopub.status.busy":"2023-11-08T21:59:24.631847Z","iopub.status.idle":"2023-11-08T21:59:34.538413Z","shell.execute_reply":"2023-11-08T21:59:34.537474Z","shell.execute_reply.started":"2023-11-08T21:59:24.632738Z"},"trusted":true},"outputs":[],"source":["import os\n","import numpy as np\n","from scipy import stats as st\n","import pandas as pd\n","import cv2\n","import matplotlib.pyplot as plt\n","#import scienceplots\n","import tensorflow as tf\n","from sklearn.model_selection import train_test_split\n","import random\n","from tensorflow.keras.models import Model\n","from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, EarlyStopping, TensorBoard\n","import tensorflow.keras.callbacks\n","from keras import backend as K\n","from keras.regularizers import l2\n","import albumentations as A\n","import nibabel as nib\n","from PIL import Image"]},{"cell_type":"code","execution_count":2,"metadata":{"execution":{"iopub.execute_input":"2023-11-08T21:59:41.862207Z","iopub.status.busy":"2023-11-08T21:59:41.861267Z","iopub.status.idle":"2023-11-08T21:59:41.867312Z","shell.execute_reply":"2023-11-08T21:59:41.866286Z","shell.execute_reply.started":"2023-11-08T21:59:41.862169Z"},"trusted":true},"outputs":[],"source":["train_transforms = A.Compose([\n","    A.VerticalFlip(),\n","    A.HorizontalFlip(),\n","    A.Rotate(limit=30)\n","    # A.GaussNoise(var_limit=0.015)\n","])\n","\n","val_transforms = A.Compose([\n","    A.NoOp()\n","])"]},{"cell_type":"code","execution_count":3,"metadata":{"execution":{"iopub.execute_input":"2023-11-08T21:59:50.277474Z","iopub.status.busy":"2023-11-08T21:59:50.276624Z","iopub.status.idle":"2023-11-08T21:59:50.283855Z","shell.execute_reply":"2023-11-08T21:59:50.282832Z","shell.execute_reply.started":"2023-11-08T21:59:50.277441Z"},"trusted":true},"outputs":[],"source":["def visualize(**images):\n","    n = len(images)\n","    plt.figure(figsize=(9, 9))\n","    for i, (name, image) in enumerate(images.items()):\n","        plt.subplot(1, n, i + 1)\n","        plt.title(' '.join(name.split('_')).title())\n","\n","        if 'mask' in name:\n","            if image.ndim == 3 and image.shape[-1] > 1:\n","                image = np.argmax(image, axis=-1)\n","                \n","        plt.imshow(image, cmap = 'bone')\n","    plt.show()"]},{"cell_type":"code","execution_count":4,"metadata":{"execution":{"iopub.execute_input":"2023-11-08T21:59:51.925390Z","iopub.status.busy":"2023-11-08T21:59:51.924582Z","iopub.status.idle":"2023-11-08T21:59:51.931272Z","shell.execute_reply":"2023-11-08T21:59:51.930146Z","shell.execute_reply.started":"2023-11-08T21:59:51.925359Z"},"trusted":true},"outputs":[],"source":["def read_image(x):\n","    x = cv2.imread(x, cv2.IMREAD_GRAYSCALE)\n","    x = x / 255.0\n","    x = x.astype(np.float32)\n","    x = np.expand_dims(x, axis=-1)\n","    x = np.repeat(x, 3, axis=-1)\n","    return x\n","\n","def read_mask(x):\n","    x = cv2.imread(x, cv2.IMREAD_GRAYSCALE)\n","    x = x.astype(np.int32)\n","    return x"]},{"cell_type":"markdown","metadata":{},"source":["# todo: заменить train test split на tf.keras.utils.split_dataset при бОльшем размере датасета"]},{"cell_type":"code","execution_count":5,"metadata":{"execution":{"iopub.execute_input":"2023-11-08T21:59:52.910164Z","iopub.status.busy":"2023-11-08T21:59:52.909471Z","iopub.status.idle":"2023-11-08T21:59:52.917188Z","shell.execute_reply":"2023-11-08T21:59:52.916099Z","shell.execute_reply.started":"2023-11-08T21:59:52.910131Z"},"trusted":true},"outputs":[],"source":["def load_data(x_path, y_path):\n","    images = os.listdir(x_path)\n","    masks = os.listdir(y_path)\n","    \n","    X = [os.path.join(x_path, image) for image in images]\n","    y = [os.path.join(y_path, mask) for mask in masks]\n","    \n","    train_x, val_x, train_y, val_y = train_test_split(X, y, test_size=0.15, random_state=42)\n","    train_x, test_x, train_y, test_y = train_test_split(train_x, train_y, test_size=0.15/(1-0.15), random_state=42)\n","\n","    return X, y"]},{"cell_type":"code","execution_count":6,"metadata":{"execution":{"iopub.execute_input":"2023-11-08T21:59:54.278236Z","iopub.status.busy":"2023-11-08T21:59:54.277730Z","iopub.status.idle":"2023-11-08T21:59:54.291776Z","shell.execute_reply":"2023-11-08T21:59:54.290783Z","shell.execute_reply.started":"2023-11-08T21:59:54.278193Z"},"trusted":true},"outputs":[],"source":["def tf_dataset(x, y, transformations, batch=8):\n","    dataset = tf.data.Dataset.from_tensor_slices((x,y))\n","    dataset = dataset.shuffle(buffer_size=len(x))\n","    dataset = dataset.map(lambda x, y: preprocess(x, y, transformations))\n","    dataset = dataset.batch(batch)\n","    dataset = dataset.repeat()\n","    dataset = dataset.prefetch(2)\n","    return dataset\n","\n","def preprocess(x, y, transformations):\n","\n","    def aug(x,y):\n","        x = x.decode()\n","        y = y.decode()\n","        image = read_image(x)\n","        mask = read_mask(y)\n","        augmented = transformations(image=image,mask=mask)\n","        aug_img=augmented['image']\n","        aug_mask = augmented['mask']\n","        return aug_img, aug_mask\n","    \n","    image, mask = tf.numpy_function(aug, [x,y], [tf.float32, tf.int32])\n","\n","    mask = tf.one_hot(mask, 3, dtype = tf.int32) #обязательно так как сегментация мультиклассовая\n","\n","    image.set_shape([512,512,3])\n","    mask.set_shape([512,512,3])\n","\n","    return image, mask"]},{"cell_type":"code","execution_count":7,"metadata":{},"outputs":[],"source":["Ncl = 3\n","w = K.zeros(shape=(Ncl,))\n","\n","def generalized_dice_coeff(y_true, y_pred):\n","    y_pred = K.cast(y_pred, 'float32')\n","    y_true = K.cast(y_true, 'float32')\n","    w = K.sum(y_true, axis=(0,1,2))\n","    w = 1.0/(w**2+0.000001)\n","\n","    numerator = y_true*y_pred\n","    numerator = w*K.sum(numerator,(0,1,2))\n","    numerator = K.sum(numerator)\n","\n","    denominator = y_true+y_pred\n","    denominator = w*K.sum(denominator,(0,1,2))\n","    denominator = K.sum(denominator)\n","\n","    gen_dice_coef = 2*numerator/denominator\n","\n","    return gen_dice_coef\n","\n","def generalized_dice_loss(y_true, y_pred):\n","    return 1 - generalized_dice_coeff(y_true, y_pred)"]},{"cell_type":"markdown","metadata":{},"source":["<!-- Ncl = 3\n","w = K.zeros(shape=(Ncl,))\n","\n","def generalized_dice_coeff(y_true, y_pred):\n","    y_pred = K.cast(y_pred, 'float32')\n","    y_true = K.cast(y_true, 'float32')\n","    w = K.sum(y_true, axis=(0,1,2))\n","\n","    w = 1.0/(w**2+0.000001)\n","    \n","    numerator = y_true*y_pred\n","    print(numerator.shape)\n","    numerator = w*K.sum(numerator,(0, 1, 2))\n","    print(numerator, numerator.shape)\n","    numerator = K.sum(numerator)\n","    print(numerator, numerator.shape)\n","\n","\n","    denominator = y_true+y_pred\n","    denominator = w*K.sum(denominator,(0,1,2))\n","    denominator = K.sum(denominator)\n","\n","    gen_dice_coef = 2*numerator/denominator\n","\n","    return gen_dice_coef\n","\n","def generalized_dice_loss(y_true, y_pred):\n","    return 1 - generalized_dice_coeff(y_true, y_pred) -->"]},{"cell_type":"code","execution_count":8,"metadata":{},"outputs":[],"source":["# def tversky_coeff(y_true, y_pred, beta):\n","#     y_pred = K.cast(y_pred, 'float32')\n","#     y_true = K.cast(y_true, 'float32')\n","#     w = K.sum(y_true, axis=(0,1,2))\n","\n","#     w = 1.0/(w**2+0.000001)\n","#     smooth = 1\n","#     print(y_true.shape)\n","#     y_true = K.permute_dimensions(y_true, (3,1,2,0))\n","#     y_pred = K.permute_dimensions(y_pred, (3,1,2,0))\n","#     print(y_true.shape)\n","#     y_true_pos = K.batch_flatten(y_true)\n","#     y_pred_pos = K.batch_flatten(y_pred)\n","#     true_pos = w*K.sum(y_true_pos * y_pred_pos, 1)\n","#     print((y_true_pos * y_true_pos).shape, true_pos)\n","#     false_neg = K.sum(y_true_pos * (1-y_pred_pos), 1)\n","#     false_pos = K.sum((1-y_true_pos)*y_pred_pos, 1)\n","\n","#     denominator = true_pos + beta*false_pos + (1-beta)*false_neg + smooth\n","\n","#     return K.mean((true_pos + smooth)/(denominator))\n","\n","# def tversky_loss(y_true, y_pred, beta=0.4):\n","#     return 1 - tversky_coeff(y_true, y_pred, beta)"]},{"cell_type":"code","execution_count":9,"metadata":{},"outputs":[],"source":["# def tversky_coeff(y_true, y_pred, beta):\n","#     y_pred = K.cast(y_pred, 'float32')\n","#     y_true = K.cast(y_true, 'float32')\n","#     smooth = 1\n","\n","#     y_true = K.permute_dimensions(y_true, (3,1,2,0))\n","#     y_pred = K.permute_dimensions(y_pred, (3,1,2,0))\n","\n","#     y_true_pos = K.batch_flatten(y_true)\n","#     y_pred_pos = K.batch_flatten(y_pred)\n","#     true_pos = K.sum(y_true_pos * y_pred_pos, 1)\n","#     false_neg = K.sum(y_true_pos * (1-y_pred_pos), 1)\n","#     false_pos = K.sum((1-y_true_pos)*y_pred_pos, 1)\n","\n","#     return K.mean((true_pos + smooth)/(true_pos + beta*false_pos + (1-beta)*false_neg + smooth))\n","\n","# def tversky_loss(y_true, y_pred, beta=0.4):\n","#     return 1 - tversky_coeff(y_true, y_pred, beta)"]},{"cell_type":"code","execution_count":10,"metadata":{},"outputs":[],"source":["def tversky(y_true, y_pred, axis=(0, 1, 2), alpha=0.5, beta=0.5, smooth=0.0001):\n","    \"Tversky metric\"\n","    y_true = tf.cast(y_true, tf.float32)\n","    y_pred = tf.cast(y_pred, tf.float32)\n","    tp = tf.math.reduce_sum(y_true * y_pred, axis=axis) # calculate True Positive\n","    fn = tf.math.reduce_sum(y_true * (1 - y_pred), axis=axis) # calculate False Negative\n","    fp = tf.math.reduce_sum((1 - y_true) * y_pred, axis=axis) # calculate False Positive\n","    tv = (tp + smooth) / (tp + alpha * fn + beta * fp + smooth) # calculate tversky\n","    tv = tf.math.reduce_mean(tv)\n","    return tv\n","def focal_tversky_loss(y_true, y_pred, gamma=1):\n","    tv = tversky(y_true, y_pred)\n","    return K.pow((1 - tv), gamma)"]},{"cell_type":"code","execution_count":11,"metadata":{"execution":{"iopub.execute_input":"2023-11-08T21:59:57.788502Z","iopub.status.busy":"2023-11-08T21:59:57.788135Z","iopub.status.idle":"2023-11-08T21:59:57.794530Z","shell.execute_reply":"2023-11-08T21:59:57.793467Z","shell.execute_reply.started":"2023-11-08T21:59:57.788475Z"},"trusted":true},"outputs":[],"source":["class LossHistory(tensorflow.keras.callbacks.Callback):\n","    def on_train_begin(self, logs={}):\n","        self.losses = []\n","\n","    def on_epoch_end(self, batch, logs={}):\n","        self.losses.append(logs.get('loss'))"]},{"cell_type":"markdown","metadata":{},"source":["## Гиперпараметры для моделей"]},{"cell_type":"code","execution_count":12,"metadata":{},"outputs":[],"source":["IMG_HEIGHT = 512\n","IMG_WIDTH = 512\n","IMG_CHANNELS = 3\n","n_classes = 3\n","\n","LR = 1e-4\n","epochs = 25"]},{"cell_type":"markdown","metadata":{},"source":["## Формирование датасета и Визуализация"]},{"cell_type":"code","execution_count":13,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["Training set size: 6519\n","Validation set size: 1494\n","Test set size: 1201\n"]}],"source":["np.random.seed(42)\n","tf.random.set_seed(42)\n","batch_size = 2\n","\n","# images_path = r\"C:\\Users\\stepan\\ML\\datasets\\andrey_dataset\\Train_Ct-Scan\"\n","# masks_path = r\"C:\\Users\\stepan\\ML\\datasets\\andrey_dataset\\Train_Ct-Scan_masks\"\n","\n","# train_x, train_y, val_x, val_y, test_x, test_y = load_data(images_path, masks_path)\n","\n","train_images_path, train_masks_path = r\"C:\\Users\\stepan\\ML\\datasets\\130liverscans\\minor_dataset\\train\\new_images\", r\"C:\\Users\\stepan\\ML\\datasets\\130liverscans\\minor_dataset\\train\\new_masks\"\n","\n","val_images_path, val_masks_path = r\"C:\\Users\\stepan\\ML\\datasets\\130liverscans\\minor_dataset\\val\\new_images\", r\"C:\\Users\\stepan\\ML\\datasets\\130liverscans\\minor_dataset\\val\\new_masks\"\n","\n","test_images_path, test_masks_path = r\"C:\\Users\\stepan\\ML\\datasets\\130liverscans\\minor_dataset\\test\\new_images\", r\"C:\\Users\\stepan\\ML\\datasets\\130liverscans\\minor_dataset\\test\\new_masks\"\n","\n","train_x, train_y  = load_data(train_images_path, train_masks_path)\n","\n","val_x, val_y = load_data(val_images_path, val_masks_path)\n","\n","test_x, test_y = load_data(test_images_path, test_masks_path)\n","\n","print(f'Training set size: {len(train_x)}')\n","print(f'Validation set size: {len(val_x)}')\n","print(f'Test set size: {len(test_x)}')\n","\n","train_ds = tf_dataset(train_x, train_y, transformations=train_transforms, batch=batch_size)\n","val_ds = tf_dataset(val_x, val_y, transformations=val_transforms, batch=batch_size)"]},{"cell_type":"code","execution_count":14,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["(2, 512, 512, 3)\n","0\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 900x900 with 2 Axes>"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["1\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 900x900 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["for images, labels in train_ds.take(1): \n","    numpy_images = images.numpy()\n","    numpy_masks = labels.numpy()\n","    print(numpy_masks.shape)\n","    for i in range(numpy_images.shape[0]):\n","        print(i)\n","        visualize(image = numpy_images[i, ...], mask = numpy_masks[i, ...])"]},{"cell_type":"code","execution_count":15,"metadata":{},"outputs":[],"source":["train_steps = len(train_x)//batch_size\n","valid_steps = len(val_x)//batch_size"]},{"cell_type":"code","execution_count":16,"metadata":{},"outputs":[],"source":["from keras.layers import Input, Conv2D, MaxPooling2D, UpSampling2D, Concatenate, concatenate, Conv2DTranspose, Activation, BatchNormalization, Dropout, Lambda\n"]},{"cell_type":"markdown","metadata":{},"source":["## Модель resunet plus plus "]},{"cell_type":"code","execution_count":17,"metadata":{},"outputs":[],"source":["import tensorflow.keras.layers as L\n","from tensorflow.keras.models import Model\n","from keras.layers import Multiply, Add, GlobalAveragePooling2D, Reshape, Dense\n","\n","def SE(inputs, ratio=8):\n","    channel_axis = -1\n","    num_filters = inputs.shape[channel_axis]\n","    se_shape = (1, 1, num_filters)\n","\n","    x = GlobalAveragePooling2D()(inputs)\n","    x = Reshape(se_shape)(x)\n","    x = Dense(num_filters // ratio, activation='relu', use_bias=False)(x)\n","    x = Dense(num_filters, activation='sigmoid', use_bias=False)(x)\n","\n","    x = Multiply()([inputs, x])\n","    return x\n","\n","\n","def stem_block(inputs, num_filters):\n","    ## Conv 1\n","    x = Conv2D(num_filters, 3, padding=\"same\")(inputs)\n","    x = BatchNormalization()(x)\n","    x = Activation(\"relu\")(x)\n","    x = Conv2D(num_filters, 3, padding=\"same\")(x)\n","\n","    ## Shortcut\n","    s = Conv2D(num_filters, 1, padding=\"same\")(inputs)\n","\n","    ## Add\n","    x = Add()([x, s])\n","    return x\n","\n","def resnet_block(inputs, num_filters, strides=1):\n","    ## SE\n","    inputs = SE(inputs)\n","\n","    ## Conv 1\n","    x = BatchNormalization()(inputs)\n","    x = Activation(\"relu\")(x)\n","    x = Conv2D(num_filters, 3, padding=\"same\", strides=strides)(x)\n","\n","    ## Conv 2\n","    x = BatchNormalization()(x)\n","    x = Activation(\"relu\")(x)\n","    x = Conv2D(num_filters, 3, padding=\"same\", strides=1)(x)\n","\n","    ## Shortcut\n","    s = Conv2D(num_filters, 1, padding=\"same\", strides=strides)(inputs)\n","\n","    ## Add\n","    x = Add()([x, s])\n","\n","    return x\n","\n","def aspp_block(inputs, num_filters):\n","    x1 = Conv2D(num_filters, 3, dilation_rate=6, padding=\"same\")(inputs)\n","    x1 = BatchNormalization()(x1)\n","\n","    x2 = Conv2D(num_filters, 3, dilation_rate=12, padding=\"same\")(inputs)\n","    x2 = BatchNormalization()(x2)\n","\n","    x3 = Conv2D(num_filters, 3, dilation_rate=18, padding=\"same\")(inputs)\n","    x3 = BatchNormalization()(x3)\n","\n","    x4 = Conv2D(num_filters, (3, 3), padding=\"same\")(inputs)\n","    x4 = BatchNormalization()(x4)\n","\n","    y = Add()([x1, x2, x3, x4])\n","    y = Conv2D(num_filters, 1, padding=\"same\")(y)\n","\n","    return y\n","\n","def attetion_block(x1, x2):\n","    num_filters = x2.shape[-1]\n","\n","    x1_conv = BatchNormalization()(x1)\n","    x1_conv = Activation(\"relu\")(x1_conv)\n","    x1_conv = Conv2D(num_filters, 3, padding=\"same\")(x1_conv)\n","    x1_pool = MaxPooling2D((2, 2))(x1_conv)\n","\n","    x2_conv = BatchNormalization()(x2)\n","    x2_conv = Activation(\"relu\")(x2_conv)\n","    x2_conv = Conv2D(num_filters, 3, padding=\"same\")(x2_conv)\n","\n","    x = Add()([x1_pool, x2_conv])\n","\n","    x = BatchNormalization()(x)\n","    x = Activation(\"relu\")(x)\n","    x = Conv2D(num_filters, 3, padding=\"same\")(x)\n","\n","    x = Multiply()([x, x2])\n","    return x\n","\n","def resunet_pp(n_classes, IMG_HEIGHT=IMG_HEIGHT, IMG_WIDTH=IMG_WIDTH, IMG_CHANNELS=IMG_CHANNELS):\n","\n","    inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS))\n","\n","    # encoding\n","    c1 = stem_block(inputs, 16)\n","    c2 = resnet_block(c1, 32, strides=2)\n","    c3 = resnet_block(c2, 64, strides=2)\n","    c4 = resnet_block(c3, 128, strides=2)\n","\n","    # bridge\n","    b1 = aspp_block(c4, 256)\n","\n","    # decoding\n","    d1 = attetion_block(c3, b1)\n","    d1 = UpSampling2D((2, 2))(d1)\n","    d1 = Concatenate()([d1, c3])\n","    d1 = resnet_block(d1, 128)\n","\n","    d2 = attetion_block(c2, d1)\n","    d2 = UpSampling2D((2, 2))(d2)\n","    d2 = Concatenate()([d2, c2])\n","    d2 = resnet_block(d2, 64)\n","\n","    d3 = attetion_block(c1, d2)\n","    d3 = UpSampling2D((2, 2))(d3)\n","    d3 = Concatenate()([d3, c1])\n","    d3 = resnet_block(d3, 32)\n","\n","    outputs = aspp_block(d3, 16)\n","    outputs = Conv2D(n_classes, 1, padding=\"same\")(outputs)\n","    outputs = Activation(\"softmax\")(outputs)\n","\n","    model = Model(inputs, outputs, name='RESUNET_pp')\n","    return model"]},{"cell_type":"code","execution_count":18,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["Model: \"RESUNET_pp\"\n","__________________________________________________________________________________________________\n"," Layer (type)                   Output Shape         Param #     Connected to                     \n","==================================================================================================\n"," input_1 (InputLayer)           [(None, 512, 512, 3  0           []                               \n","                                )]                                                                \n","                                                                                                  \n"," conv2d (Conv2D)                (None, 512, 512, 16  448         ['input_1[0][0]']                \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization (BatchNorm  (None, 512, 512, 16  64         ['conv2d[0][0]']                 \n"," alization)                     )                                                                 \n","                                                                                                  \n"," activation (Activation)        (None, 512, 512, 16  0           ['batch_normalization[0][0]']    \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_1 (Conv2D)              (None, 512, 512, 16  2320        ['activation[0][0]']             \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_2 (Conv2D)              (None, 512, 512, 16  64          ['input_1[0][0]']                \n","                                )                                                                 \n","                                                                                                  \n"," add (Add)                      (None, 512, 512, 16  0           ['conv2d_1[0][0]',               \n","                                )                                 'conv2d_2[0][0]']               \n","                                                                                                  \n"," global_average_pooling2d (Glob  (None, 16)          0           ['add[0][0]']                    \n"," alAveragePooling2D)                                                                              \n","                                                                                                  \n"," reshape (Reshape)              (None, 1, 1, 16)     0           ['global_average_pooling2d[0][0]'\n","                                                                 ]                                \n","                                                                                                  \n"," dense (Dense)                  (None, 1, 1, 2)      32          ['reshape[0][0]']                \n","                                                                                                  \n"," dense_1 (Dense)                (None, 1, 1, 16)     32          ['dense[0][0]']                  \n","                                                                                                  \n"," multiply (Multiply)            (None, 512, 512, 16  0           ['add[0][0]',                    \n","                                )                                 'dense_1[0][0]']                \n","                                                                                                  \n"," batch_normalization_1 (BatchNo  (None, 512, 512, 16  64         ['multiply[0][0]']               \n"," rmalization)                   )                                                                 \n","                                                                                                  \n"," activation_1 (Activation)      (None, 512, 512, 16  0           ['batch_normalization_1[0][0]']  \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_3 (Conv2D)              (None, 256, 256, 32  4640        ['activation_1[0][0]']           \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_2 (BatchNo  (None, 256, 256, 32  128        ['conv2d_3[0][0]']               \n"," rmalization)                   )                                                                 \n","                                                                                                  \n"," activation_2 (Activation)      (None, 256, 256, 32  0           ['batch_normalization_2[0][0]']  \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_4 (Conv2D)              (None, 256, 256, 32  9248        ['activation_2[0][0]']           \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_5 (Conv2D)              (None, 256, 256, 32  544         ['multiply[0][0]']               \n","                                )                                                                 \n","                                                                                                  \n"," add_1 (Add)                    (None, 256, 256, 32  0           ['conv2d_4[0][0]',               \n","                                )                                 'conv2d_5[0][0]']               \n","                                                                                                  \n"," global_average_pooling2d_1 (Gl  (None, 32)          0           ['add_1[0][0]']                  \n"," obalAveragePooling2D)                                                                            \n","                                                                                                  \n"," reshape_1 (Reshape)            (None, 1, 1, 32)     0           ['global_average_pooling2d_1[0][0\n","                                                                 ]']                              \n","                                                                                                  \n"," dense_2 (Dense)                (None, 1, 1, 4)      128         ['reshape_1[0][0]']              \n","                                                                                                  \n"," dense_3 (Dense)                (None, 1, 1, 32)     128         ['dense_2[0][0]']                \n","                                                                                                  \n"," multiply_1 (Multiply)          (None, 256, 256, 32  0           ['add_1[0][0]',                  \n","                                )                                 'dense_3[0][0]']                \n","                                                                                                  \n"," batch_normalization_3 (BatchNo  (None, 256, 256, 32  128        ['multiply_1[0][0]']             \n"," rmalization)                   )                                                                 \n","                                                                                                  \n"," activation_3 (Activation)      (None, 256, 256, 32  0           ['batch_normalization_3[0][0]']  \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_6 (Conv2D)              (None, 128, 128, 64  18496       ['activation_3[0][0]']           \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_4 (BatchNo  (None, 128, 128, 64  256        ['conv2d_6[0][0]']               \n"," rmalization)                   )                                                                 \n","                                                                                                  \n"," activation_4 (Activation)      (None, 128, 128, 64  0           ['batch_normalization_4[0][0]']  \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_7 (Conv2D)              (None, 128, 128, 64  36928       ['activation_4[0][0]']           \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_8 (Conv2D)              (None, 128, 128, 64  2112        ['multiply_1[0][0]']             \n","                                )                                                                 \n","                                                                                                  \n"," add_2 (Add)                    (None, 128, 128, 64  0           ['conv2d_7[0][0]',               \n","                                )                                 'conv2d_8[0][0]']               \n","                                                                                                  \n"," global_average_pooling2d_2 (Gl  (None, 64)          0           ['add_2[0][0]']                  \n"," obalAveragePooling2D)                                                                            \n","                                                                                                  \n"," reshape_2 (Reshape)            (None, 1, 1, 64)     0           ['global_average_pooling2d_2[0][0\n","                                                                 ]']                              \n","                                                                                                  \n"," dense_4 (Dense)                (None, 1, 1, 8)      512         ['reshape_2[0][0]']              \n","                                                                                                  \n"," dense_5 (Dense)                (None, 1, 1, 64)     512         ['dense_4[0][0]']                \n","                                                                                                  \n"," multiply_2 (Multiply)          (None, 128, 128, 64  0           ['add_2[0][0]',                  \n","                                )                                 'dense_5[0][0]']                \n","                                                                                                  \n"," batch_normalization_5 (BatchNo  (None, 128, 128, 64  256        ['multiply_2[0][0]']             \n"," rmalization)                   )                                                                 \n","                                                                                                  \n"," activation_5 (Activation)      (None, 128, 128, 64  0           ['batch_normalization_5[0][0]']  \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_9 (Conv2D)              (None, 64, 64, 128)  73856       ['activation_5[0][0]']           \n","                                                                                                  \n"," batch_normalization_6 (BatchNo  (None, 64, 64, 128)  512        ['conv2d_9[0][0]']               \n"," rmalization)                                                                                     \n","                                                                                                  \n"," activation_6 (Activation)      (None, 64, 64, 128)  0           ['batch_normalization_6[0][0]']  \n","                                                                                                  \n"," conv2d_10 (Conv2D)             (None, 64, 64, 128)  147584      ['activation_6[0][0]']           \n","                                                                                                  \n"," conv2d_11 (Conv2D)             (None, 64, 64, 128)  8320        ['multiply_2[0][0]']             \n","                                                                                                  \n"," add_3 (Add)                    (None, 64, 64, 128)  0           ['conv2d_10[0][0]',              \n","                                                                  'conv2d_11[0][0]']              \n","                                                                                                  \n"," conv2d_12 (Conv2D)             (None, 64, 64, 256)  295168      ['add_3[0][0]']                  \n","                                                                                                  \n"," conv2d_13 (Conv2D)             (None, 64, 64, 256)  295168      ['add_3[0][0]']                  \n","                                                                                                  \n"," conv2d_14 (Conv2D)             (None, 64, 64, 256)  295168      ['add_3[0][0]']                  \n","                                                                                                  \n"," conv2d_15 (Conv2D)             (None, 64, 64, 256)  295168      ['add_3[0][0]']                  \n","                                                                                                  \n"," batch_normalization_7 (BatchNo  (None, 64, 64, 256)  1024       ['conv2d_12[0][0]']              \n"," rmalization)                                                                                     \n","                                                                                                  \n"," batch_normalization_8 (BatchNo  (None, 64, 64, 256)  1024       ['conv2d_13[0][0]']              \n"," rmalization)                                                                                     \n","                                                                                                  \n"," batch_normalization_9 (BatchNo  (None, 64, 64, 256)  1024       ['conv2d_14[0][0]']              \n"," rmalization)                                                                                     \n","                                                                                                  \n"," batch_normalization_10 (BatchN  (None, 64, 64, 256)  1024       ['conv2d_15[0][0]']              \n"," ormalization)                                                                                    \n","                                                                                                  \n"," add_4 (Add)                    (None, 64, 64, 256)  0           ['batch_normalization_7[0][0]',  \n","                                                                  'batch_normalization_8[0][0]',  \n","                                                                  'batch_normalization_9[0][0]',  \n","                                                                  'batch_normalization_10[0][0]'] \n","                                                                                                  \n"," batch_normalization_11 (BatchN  (None, 128, 128, 64  256        ['add_2[0][0]']                  \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," conv2d_16 (Conv2D)             (None, 64, 64, 256)  65792       ['add_4[0][0]']                  \n","                                                                                                  \n"," activation_7 (Activation)      (None, 128, 128, 64  0           ['batch_normalization_11[0][0]'] \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_12 (BatchN  (None, 64, 64, 256)  1024       ['conv2d_16[0][0]']              \n"," ormalization)                                                                                    \n","                                                                                                  \n"," conv2d_17 (Conv2D)             (None, 128, 128, 25  147712      ['activation_7[0][0]']           \n","                                6)                                                                \n","                                                                                                  \n"," activation_8 (Activation)      (None, 64, 64, 256)  0           ['batch_normalization_12[0][0]'] \n","                                                                                                  \n"," max_pooling2d (MaxPooling2D)   (None, 64, 64, 256)  0           ['conv2d_17[0][0]']              \n","                                                                                                  \n"," conv2d_18 (Conv2D)             (None, 64, 64, 256)  590080      ['activation_8[0][0]']           \n","                                                                                                  \n"," add_5 (Add)                    (None, 64, 64, 256)  0           ['max_pooling2d[0][0]',          \n","                                                                  'conv2d_18[0][0]']              \n","                                                                                                  \n"," batch_normalization_13 (BatchN  (None, 64, 64, 256)  1024       ['add_5[0][0]']                  \n"," ormalization)                                                                                    \n","                                                                                                  \n"," activation_9 (Activation)      (None, 64, 64, 256)  0           ['batch_normalization_13[0][0]'] \n","                                                                                                  \n"," conv2d_19 (Conv2D)             (None, 64, 64, 256)  590080      ['activation_9[0][0]']           \n","                                                                                                  \n"," multiply_3 (Multiply)          (None, 64, 64, 256)  0           ['conv2d_19[0][0]',              \n","                                                                  'conv2d_16[0][0]']              \n","                                                                                                  \n"," up_sampling2d (UpSampling2D)   (None, 128, 128, 25  0           ['multiply_3[0][0]']             \n","                                6)                                                                \n","                                                                                                  \n"," concatenate (Concatenate)      (None, 128, 128, 32  0           ['up_sampling2d[0][0]',          \n","                                0)                                'add_2[0][0]']                  \n","                                                                                                  \n"," global_average_pooling2d_3 (Gl  (None, 320)         0           ['concatenate[0][0]']            \n"," obalAveragePooling2D)                                                                            \n","                                                                                                  \n"," reshape_3 (Reshape)            (None, 1, 1, 320)    0           ['global_average_pooling2d_3[0][0\n","                                                                 ]']                              \n","                                                                                                  \n"," dense_6 (Dense)                (None, 1, 1, 40)     12800       ['reshape_3[0][0]']              \n","                                                                                                  \n"," dense_7 (Dense)                (None, 1, 1, 320)    12800       ['dense_6[0][0]']                \n","                                                                                                  \n"," multiply_4 (Multiply)          (None, 128, 128, 32  0           ['concatenate[0][0]',            \n","                                0)                                'dense_7[0][0]']                \n","                                                                                                  \n"," batch_normalization_14 (BatchN  (None, 128, 128, 32  1280       ['multiply_4[0][0]']             \n"," ormalization)                  0)                                                                \n","                                                                                                  \n"," activation_10 (Activation)     (None, 128, 128, 32  0           ['batch_normalization_14[0][0]'] \n","                                0)                                                                \n","                                                                                                  \n"," conv2d_20 (Conv2D)             (None, 128, 128, 12  368768      ['activation_10[0][0]']          \n","                                8)                                                                \n","                                                                                                  \n"," batch_normalization_15 (BatchN  (None, 128, 128, 12  512        ['conv2d_20[0][0]']              \n"," ormalization)                  8)                                                                \n","                                                                                                  \n"," activation_11 (Activation)     (None, 128, 128, 12  0           ['batch_normalization_15[0][0]'] \n","                                8)                                                                \n","                                                                                                  \n"," conv2d_21 (Conv2D)             (None, 128, 128, 12  147584      ['activation_11[0][0]']          \n","                                8)                                                                \n","                                                                                                  \n"," conv2d_22 (Conv2D)             (None, 128, 128, 12  41088       ['multiply_4[0][0]']             \n","                                8)                                                                \n","                                                                                                  \n"," batch_normalization_16 (BatchN  (None, 256, 256, 32  128        ['add_1[0][0]']                  \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," add_6 (Add)                    (None, 128, 128, 12  0           ['conv2d_21[0][0]',              \n","                                8)                                'conv2d_22[0][0]']              \n","                                                                                                  \n"," activation_12 (Activation)     (None, 256, 256, 32  0           ['batch_normalization_16[0][0]'] \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_17 (BatchN  (None, 128, 128, 12  512        ['add_6[0][0]']                  \n"," ormalization)                  8)                                                                \n","                                                                                                  \n"," conv2d_23 (Conv2D)             (None, 256, 256, 12  36992       ['activation_12[0][0]']          \n","                                8)                                                                \n","                                                                                                  \n"," activation_13 (Activation)     (None, 128, 128, 12  0           ['batch_normalization_17[0][0]'] \n","                                8)                                                                \n","                                                                                                  \n"," max_pooling2d_1 (MaxPooling2D)  (None, 128, 128, 12  0          ['conv2d_23[0][0]']              \n","                                8)                                                                \n","                                                                                                  \n"," conv2d_24 (Conv2D)             (None, 128, 128, 12  147584      ['activation_13[0][0]']          \n","                                8)                                                                \n","                                                                                                  \n"," add_7 (Add)                    (None, 128, 128, 12  0           ['max_pooling2d_1[0][0]',        \n","                                8)                                'conv2d_24[0][0]']              \n","                                                                                                  \n"," batch_normalization_18 (BatchN  (None, 128, 128, 12  512        ['add_7[0][0]']                  \n"," ormalization)                  8)                                                                \n","                                                                                                  \n"," activation_14 (Activation)     (None, 128, 128, 12  0           ['batch_normalization_18[0][0]'] \n","                                8)                                                                \n","                                                                                                  \n"," conv2d_25 (Conv2D)             (None, 128, 128, 12  147584      ['activation_14[0][0]']          \n","                                8)                                                                \n","                                                                                                  \n"," multiply_5 (Multiply)          (None, 128, 128, 12  0           ['conv2d_25[0][0]',              \n","                                8)                                'add_6[0][0]']                  \n","                                                                                                  \n"," up_sampling2d_1 (UpSampling2D)  (None, 256, 256, 12  0          ['multiply_5[0][0]']             \n","                                8)                                                                \n","                                                                                                  \n"," concatenate_1 (Concatenate)    (None, 256, 256, 16  0           ['up_sampling2d_1[0][0]',        \n","                                0)                                'add_1[0][0]']                  \n","                                                                                                  \n"," global_average_pooling2d_4 (Gl  (None, 160)         0           ['concatenate_1[0][0]']          \n"," obalAveragePooling2D)                                                                            \n","                                                                                                  \n"," reshape_4 (Reshape)            (None, 1, 1, 160)    0           ['global_average_pooling2d_4[0][0\n","                                                                 ]']                              \n","                                                                                                  \n"," dense_8 (Dense)                (None, 1, 1, 20)     3200        ['reshape_4[0][0]']              \n","                                                                                                  \n"," dense_9 (Dense)                (None, 1, 1, 160)    3200        ['dense_8[0][0]']                \n","                                                                                                  \n"," multiply_6 (Multiply)          (None, 256, 256, 16  0           ['concatenate_1[0][0]',          \n","                                0)                                'dense_9[0][0]']                \n","                                                                                                  \n"," batch_normalization_19 (BatchN  (None, 256, 256, 16  640        ['multiply_6[0][0]']             \n"," ormalization)                  0)                                                                \n","                                                                                                  \n"," activation_15 (Activation)     (None, 256, 256, 16  0           ['batch_normalization_19[0][0]'] \n","                                0)                                                                \n","                                                                                                  \n"," conv2d_26 (Conv2D)             (None, 256, 256, 64  92224       ['activation_15[0][0]']          \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_20 (BatchN  (None, 256, 256, 64  256        ['conv2d_26[0][0]']              \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," activation_16 (Activation)     (None, 256, 256, 64  0           ['batch_normalization_20[0][0]'] \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_27 (Conv2D)             (None, 256, 256, 64  36928       ['activation_16[0][0]']          \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_28 (Conv2D)             (None, 256, 256, 64  10304       ['multiply_6[0][0]']             \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_21 (BatchN  (None, 512, 512, 16  64         ['add[0][0]']                    \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," add_8 (Add)                    (None, 256, 256, 64  0           ['conv2d_27[0][0]',              \n","                                )                                 'conv2d_28[0][0]']              \n","                                                                                                  \n"," activation_17 (Activation)     (None, 512, 512, 16  0           ['batch_normalization_21[0][0]'] \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_22 (BatchN  (None, 256, 256, 64  256        ['add_8[0][0]']                  \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," conv2d_29 (Conv2D)             (None, 512, 512, 64  9280        ['activation_17[0][0]']          \n","                                )                                                                 \n","                                                                                                  \n"," activation_18 (Activation)     (None, 256, 256, 64  0           ['batch_normalization_22[0][0]'] \n","                                )                                                                 \n","                                                                                                  \n"," max_pooling2d_2 (MaxPooling2D)  (None, 256, 256, 64  0          ['conv2d_29[0][0]']              \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_30 (Conv2D)             (None, 256, 256, 64  36928       ['activation_18[0][0]']          \n","                                )                                                                 \n","                                                                                                  \n"," add_9 (Add)                    (None, 256, 256, 64  0           ['max_pooling2d_2[0][0]',        \n","                                )                                 'conv2d_30[0][0]']              \n","                                                                                                  \n"," batch_normalization_23 (BatchN  (None, 256, 256, 64  256        ['add_9[0][0]']                  \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," activation_19 (Activation)     (None, 256, 256, 64  0           ['batch_normalization_23[0][0]'] \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_31 (Conv2D)             (None, 256, 256, 64  36928       ['activation_19[0][0]']          \n","                                )                                                                 \n","                                                                                                  \n"," multiply_7 (Multiply)          (None, 256, 256, 64  0           ['conv2d_31[0][0]',              \n","                                )                                 'add_8[0][0]']                  \n","                                                                                                  \n"," up_sampling2d_2 (UpSampling2D)  (None, 512, 512, 64  0          ['multiply_7[0][0]']             \n","                                )                                                                 \n","                                                                                                  \n"," concatenate_2 (Concatenate)    (None, 512, 512, 80  0           ['up_sampling2d_2[0][0]',        \n","                                )                                 'add[0][0]']                    \n","                                                                                                  \n"," global_average_pooling2d_5 (Gl  (None, 80)          0           ['concatenate_2[0][0]']          \n"," obalAveragePooling2D)                                                                            \n","                                                                                                  \n"," reshape_5 (Reshape)            (None, 1, 1, 80)     0           ['global_average_pooling2d_5[0][0\n","                                                                 ]']                              \n","                                                                                                  \n"," dense_10 (Dense)               (None, 1, 1, 10)     800         ['reshape_5[0][0]']              \n","                                                                                                  \n"," dense_11 (Dense)               (None, 1, 1, 80)     800         ['dense_10[0][0]']               \n","                                                                                                  \n"," multiply_8 (Multiply)          (None, 512, 512, 80  0           ['concatenate_2[0][0]',          \n","                                )                                 'dense_11[0][0]']               \n","                                                                                                  \n"," batch_normalization_24 (BatchN  (None, 512, 512, 80  320        ['multiply_8[0][0]']             \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," activation_20 (Activation)     (None, 512, 512, 80  0           ['batch_normalization_24[0][0]'] \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_32 (Conv2D)             (None, 512, 512, 32  23072       ['activation_20[0][0]']          \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_25 (BatchN  (None, 512, 512, 32  128        ['conv2d_32[0][0]']              \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," activation_21 (Activation)     (None, 512, 512, 32  0           ['batch_normalization_25[0][0]'] \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_33 (Conv2D)             (None, 512, 512, 32  9248        ['activation_21[0][0]']          \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_34 (Conv2D)             (None, 512, 512, 32  2592        ['multiply_8[0][0]']             \n","                                )                                                                 \n","                                                                                                  \n"," add_10 (Add)                   (None, 512, 512, 32  0           ['conv2d_33[0][0]',              \n","                                )                                 'conv2d_34[0][0]']              \n","                                                                                                  \n"," conv2d_35 (Conv2D)             (None, 512, 512, 16  4624        ['add_10[0][0]']                 \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_36 (Conv2D)             (None, 512, 512, 16  4624        ['add_10[0][0]']                 \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_37 (Conv2D)             (None, 512, 512, 16  4624        ['add_10[0][0]']                 \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_38 (Conv2D)             (None, 512, 512, 16  4624        ['add_10[0][0]']                 \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_26 (BatchN  (None, 512, 512, 16  64         ['conv2d_35[0][0]']              \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," batch_normalization_27 (BatchN  (None, 512, 512, 16  64         ['conv2d_36[0][0]']              \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," batch_normalization_28 (BatchN  (None, 512, 512, 16  64         ['conv2d_37[0][0]']              \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," batch_normalization_29 (BatchN  (None, 512, 512, 16  64         ['conv2d_38[0][0]']              \n"," ormalization)                  )                                                                 \n","                                                                                                  \n"," add_11 (Add)                   (None, 512, 512, 16  0           ['batch_normalization_26[0][0]', \n","                                )                                 'batch_normalization_27[0][0]', \n","                                                                  'batch_normalization_28[0][0]', \n","                                                                  'batch_normalization_29[0][0]'] \n","                                                                                                  \n"," conv2d_39 (Conv2D)             (None, 512, 512, 16  272         ['add_11[0][0]']                 \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_40 (Conv2D)             (None, 512, 512, 3)  51          ['conv2d_39[0][0]']              \n","                                                                                                  \n"," activation_22 (Activation)     (None, 512, 512, 3)  0           ['conv2d_40[0][0]']              \n","                                                                                                  \n","==================================================================================================\n","Total params: 4,092,691\n","Trainable params: 4,086,227\n","Non-trainable params: 6,464\n","__________________________________________________________________________________________________\n"]}],"source":["resunet_pp_model = resunet_pp(n_classes=n_classes, IMG_HEIGHT=IMG_HEIGHT, IMG_WIDTH=IMG_WIDTH, IMG_CHANNELS=IMG_CHANNELS)\n","resunet_pp_model.compile(loss=generalized_dice_loss, optimizer=tf.keras.optimizers.Adam(LR), metrics = [tf.keras.metrics.OneHotMeanIoU(num_classes=3), tversky])\n","resunet_pp_model.summary()"]},{"cell_type":"markdown","metadata":{},"source":["## Обучение resunet_pp"]},{"cell_type":"code","execution_count":19,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["Epoch 1/25\n"]},{"name":"stdout","output_type":"stream","text":["   6/3259 [..............................] - ETA: 13:53 - loss: 0.9963 - one_hot_mean_io_u: 0.1587 - tversky: 0.1887WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1081s vs `on_train_batch_end` time: 0.1553s). Check your callbacks.\n","3259/3259 [==============================] - ETA: 0s - loss: 0.8366 - one_hot_mean_io_u: 0.5176 - tversky: 0.5902\n","Epoch 1: saving model to resunet_pp_tversky_a0.5_b0.5_g1.hdf5\n","3259/3259 [==============================] - 899s 272ms/step - loss: 0.8366 - one_hot_mean_io_u: 0.5176 - tversky: 0.5902 - val_loss: 0.9556 - val_one_hot_mean_io_u: 0.5063 - val_tversky: 0.5536 - lr: 1.0000e-04\n","Epoch 2/25\n","3259/3259 [==============================] - ETA: 0s - loss: 0.7709 - one_hot_mean_io_u: 0.6300 - tversky: 0.6471\n","Epoch 2: saving model to resunet_pp_tversky_a0.5_b0.5_g1.hdf5\n","3259/3259 [==============================] - 887s 271ms/step - loss: 0.7709 - one_hot_mean_io_u: 0.6300 - tversky: 0.6471 - val_loss: 0.9276 - val_one_hot_mean_io_u: 0.5306 - val_tversky: 0.5854 - lr: 1.0000e-04\n","Epoch 3/25\n","3259/3259 [==============================] - ETA: 0s - loss: 0.7445 - one_hot_mean_io_u: 0.6541 - tversky: 0.6636\n","Epoch 3: saving model to resunet_pp_tversky_a0.5_b0.5_g1.hdf5\n","3259/3259 [==============================] - 884s 271ms/step - loss: 0.7445 - one_hot_mean_io_u: 0.6541 - tversky: 0.6636 - val_loss: 0.9397 - val_one_hot_mean_io_u: 0.5412 - val_tversky: 0.5699 - lr: 1.0000e-04\n","Epoch 4/25\n","3259/3259 [==============================] - ETA: 0s - loss: 0.7257 - one_hot_mean_io_u: 0.6717 - tversky: 0.6737\n","Epoch 4: saving model to resunet_pp_tversky_a0.5_b0.5_g1.hdf5\n","3259/3259 [==============================] - 885s 271ms/step - loss: 0.7257 - one_hot_mean_io_u: 0.6717 - tversky: 0.6737 - val_loss: 0.9381 - val_one_hot_mean_io_u: 0.5522 - val_tversky: 0.5889 - lr: 1.0000e-04\n","Epoch 5/25\n","3259/3259 [==============================] - ETA: 0s - loss: 0.7041 - one_hot_mean_io_u: 0.6878 - tversky: 0.6823\n","Epoch 5: saving model to resunet_pp_tversky_a0.5_b0.5_g1.hdf5\n","3259/3259 [==============================] - 884s 271ms/step - loss: 0.7041 - one_hot_mean_io_u: 0.6878 - tversky: 0.6823 - val_loss: 0.9110 - val_one_hot_mean_io_u: 0.5190 - val_tversky: 0.5716 - lr: 1.0000e-04\n","Epoch 6/25\n","3259/3259 [==============================] - ETA: 0s - loss: 0.6972 - one_hot_mean_io_u: 0.6912 - tversky: 0.6853\n","Epoch 6: saving model to resunet_pp_tversky_a0.5_b0.5_g1.hdf5\n","3259/3259 [==============================] - 885s 271ms/step - loss: 0.6972 - one_hot_mean_io_u: 0.6912 - tversky: 0.6853 - val_loss: 0.9760 - val_one_hot_mean_io_u: 0.4361 - val_tversky: 0.4949 - lr: 1.0000e-04\n","Epoch 7/25\n","3259/3259 [==============================] - ETA: 0s - loss: 0.6872 - one_hot_mean_io_u: 0.7115 - tversky: 0.6920\n","Epoch 7: saving model to resunet_pp_tversky_a0.5_b0.5_g1.hdf5\n","3259/3259 [==============================] - 887s 272ms/step - loss: 0.6872 - one_hot_mean_io_u: 0.7115 - tversky: 0.6920 - val_loss: 0.9056 - val_one_hot_mean_io_u: 0.6116 - val_tversky: 0.5970 - lr: 1.0000e-04\n","Epoch 8/25\n","  16/3259 [..............................] - ETA: 13:22 - loss: 0.7620 - one_hot_mean_io_u: 0.7321 - tversky: 0.6724"]},{"ename":"KeyboardInterrupt","evalue":"","output_type":"error","traceback":["\u001b[1;31m---------------------------------------------------------------------------\u001b[0m","\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","Cell \u001b[1;32mIn[19], line 11\u001b[0m\n\u001b[0;32m      1\u001b[0m history_class \u001b[38;5;241m=\u001b[39m LossHistory()\n\u001b[0;32m      3\u001b[0m callbacks \u001b[38;5;241m=\u001b[39m [\n\u001b[0;32m      4\u001b[0m     ModelCheckpoint(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mresunet_pp_tversky_a0.5_b0.5_g1.hdf5\u001b[39m\u001b[38;5;124m\"\u001b[39m, verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, save_best_model\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m),\n\u001b[0;32m      5\u001b[0m     ReduceLROnPlateau(monitor\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mval_loss\u001b[39m\u001b[38;5;124m\"\u001b[39m, patience\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m, factor\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.5\u001b[39m, verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m),\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m      8\u001b[0m     history_class\n\u001b[0;32m      9\u001b[0m ]\n\u001b[1;32m---> 11\u001b[0m resunet_pp_model_history \u001b[38;5;241m=\u001b[39m \u001b[43mresunet_pp_model\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_ds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m     12\u001b[0m \u001b[43m                    \u001b[49m\u001b[43msteps_per_epoch\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtrain_steps\u001b[49m\u001b[43m,\u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_ds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m     13\u001b[0m \u001b[43m                    \u001b[49m\u001b[43mvalidation_steps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalid_steps\u001b[49m\u001b[43m,\u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mepochs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m     14\u001b[0m \u001b[43m                    \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m     15\u001b[0m resunet_pp_model\u001b[38;5;241m.\u001b[39msave(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfinal_resunet_pp_tversky_a0.5_b0.5_g1.hdf5\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m     17\u001b[0m resunet_pp_hist_df \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(resunet_pp_model_history\u001b[38;5;241m.\u001b[39mhistory)\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\utils\\traceback_utils.py:64\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     62\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m     63\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m---> 64\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m fn(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m     65\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:  \u001b[38;5;66;03m# pylint: disable=broad-except\u001b[39;00m\n\u001b[0;32m     66\u001b[0m   filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\engine\\training.py:1389\u001b[0m, in \u001b[0;36mModel.fit\u001b[1;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[0;32m   1387\u001b[0m logs \u001b[38;5;241m=\u001b[39m tmp_logs  \u001b[38;5;66;03m# No error, now safe to assign to logs.\u001b[39;00m\n\u001b[0;32m   1388\u001b[0m end_step \u001b[38;5;241m=\u001b[39m step \u001b[38;5;241m+\u001b[39m data_handler\u001b[38;5;241m.\u001b[39mstep_increment\n\u001b[1;32m-> 1389\u001b[0m \u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mon_train_batch_end\u001b[49m\u001b[43m(\u001b[49m\u001b[43mend_step\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1390\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstop_training:\n\u001b[0;32m   1391\u001b[0m   \u001b[38;5;28;01mbreak\u001b[39;00m\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\callbacks.py:438\u001b[0m, in \u001b[0;36mCallbackList.on_train_batch_end\u001b[1;34m(self, batch, logs)\u001b[0m\n\u001b[0;32m    431\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Calls the `on_train_batch_end` methods of its callbacks.\u001b[39;00m\n\u001b[0;32m    432\u001b[0m \n\u001b[0;32m    433\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m    434\u001b[0m \u001b[38;5;124;03m    batch: Integer, index of batch within the current epoch.\u001b[39;00m\n\u001b[0;32m    435\u001b[0m \u001b[38;5;124;03m    logs: Dict. Aggregated metric results up until this batch.\u001b[39;00m\n\u001b[0;32m    436\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    437\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_should_call_train_batch_hooks:\n\u001b[1;32m--> 438\u001b[0m   \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_batch_hook\u001b[49m\u001b[43m(\u001b[49m\u001b[43mModeKeys\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTRAIN\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mend\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlogs\u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\callbacks.py:297\u001b[0m, in \u001b[0;36mCallbackList._call_batch_hook\u001b[1;34m(self, mode, hook, batch, logs)\u001b[0m\n\u001b[0;32m    295\u001b[0m   \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_batch_begin_hook(mode, batch, logs)\n\u001b[0;32m    296\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m hook \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mend\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[1;32m--> 297\u001b[0m   \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_batch_end_hook\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    298\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m    299\u001b[0m   \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m    300\u001b[0m       \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mUnrecognized hook: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mhook\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m. Expected values are [\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbegin\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mend\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m]\u001b[39m\u001b[38;5;124m'\u001b[39m)\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\callbacks.py:318\u001b[0m, in \u001b[0;36mCallbackList._call_batch_end_hook\u001b[1;34m(self, mode, batch, logs)\u001b[0m\n\u001b[0;32m    315\u001b[0m   batch_time \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime() \u001b[38;5;241m-\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_batch_start_time\n\u001b[0;32m    316\u001b[0m   \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_batch_times\u001b[38;5;241m.\u001b[39mappend(batch_time)\n\u001b[1;32m--> 318\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_batch_hook_helper\u001b[49m\u001b[43m(\u001b[49m\u001b[43mhook_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    320\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_batch_times) \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_num_batches_for_timing_check:\n\u001b[0;32m    321\u001b[0m   end_hook_name \u001b[38;5;241m=\u001b[39m hook_name\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\callbacks.py:356\u001b[0m, in \u001b[0;36mCallbackList._call_batch_hook_helper\u001b[1;34m(self, hook_name, batch, logs)\u001b[0m\n\u001b[0;32m    354\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m callback \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcallbacks:\n\u001b[0;32m    355\u001b[0m   hook \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(callback, hook_name)\n\u001b[1;32m--> 356\u001b[0m   \u001b[43mhook\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    358\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_timing:\n\u001b[0;32m    359\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m hook_name \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_hook_times:\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\callbacks.py:1034\u001b[0m, in \u001b[0;36mProgbarLogger.on_train_batch_end\u001b[1;34m(self, batch, logs)\u001b[0m\n\u001b[0;32m   1033\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mon_train_batch_end\u001b[39m(\u001b[38;5;28mself\u001b[39m, batch, logs\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m-> 1034\u001b[0m   \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_batch_update_progbar\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogs\u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\callbacks.py:1106\u001b[0m, in \u001b[0;36mProgbarLogger._batch_update_progbar\u001b[1;34m(self, batch, logs)\u001b[0m\n\u001b[0;32m   1102\u001b[0m   \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mseen \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m add_seen\n\u001b[0;32m   1104\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m   1105\u001b[0m   \u001b[38;5;66;03m# Only block async when verbose = 1.\u001b[39;00m\n\u001b[1;32m-> 1106\u001b[0m   logs \u001b[38;5;241m=\u001b[39m \u001b[43mtf_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msync_to_numpy_or_python_type\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlogs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1107\u001b[0m   \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprogbar\u001b[38;5;241m.\u001b[39mupdate(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mseen, \u001b[38;5;28mlist\u001b[39m(logs\u001b[38;5;241m.\u001b[39mitems()), finalize\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\utils\\tf_utils.py:563\u001b[0m, in \u001b[0;36msync_to_numpy_or_python_type\u001b[1;34m(tensors)\u001b[0m\n\u001b[0;32m    560\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m t\n\u001b[0;32m    561\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m t\u001b[38;5;241m.\u001b[39mitem() \u001b[38;5;28;01mif\u001b[39;00m np\u001b[38;5;241m.\u001b[39mndim(t) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m t\n\u001b[1;32m--> 563\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmap_structure\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_to_single_numpy_or_python_type\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\tensorflow\\python\\util\\nest.py:914\u001b[0m, in \u001b[0;36mmap_structure\u001b[1;34m(func, *structure, **kwargs)\u001b[0m\n\u001b[0;32m    910\u001b[0m flat_structure \u001b[38;5;241m=\u001b[39m (flatten(s, expand_composites) \u001b[38;5;28;01mfor\u001b[39;00m s \u001b[38;5;129;01min\u001b[39;00m structure)\n\u001b[0;32m    911\u001b[0m entries \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mzip\u001b[39m(\u001b[38;5;241m*\u001b[39mflat_structure)\n\u001b[0;32m    913\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m pack_sequence_as(\n\u001b[1;32m--> 914\u001b[0m     structure[\u001b[38;5;241m0\u001b[39m], [func(\u001b[38;5;241m*\u001b[39mx) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m entries],\n\u001b[0;32m    915\u001b[0m     expand_composites\u001b[38;5;241m=\u001b[39mexpand_composites)\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\tensorflow\\python\\util\\nest.py:914\u001b[0m, in \u001b[0;36m<listcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m    910\u001b[0m flat_structure \u001b[38;5;241m=\u001b[39m (flatten(s, expand_composites) \u001b[38;5;28;01mfor\u001b[39;00m s \u001b[38;5;129;01min\u001b[39;00m structure)\n\u001b[0;32m    911\u001b[0m entries \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mzip\u001b[39m(\u001b[38;5;241m*\u001b[39mflat_structure)\n\u001b[0;32m    913\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m pack_sequence_as(\n\u001b[1;32m--> 914\u001b[0m     structure[\u001b[38;5;241m0\u001b[39m], [\u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m entries],\n\u001b[0;32m    915\u001b[0m     expand_composites\u001b[38;5;241m=\u001b[39mexpand_composites)\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\utils\\tf_utils.py:557\u001b[0m, in \u001b[0;36msync_to_numpy_or_python_type.<locals>._to_single_numpy_or_python_type\u001b[1;34m(t)\u001b[0m\n\u001b[0;32m    554\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_to_single_numpy_or_python_type\u001b[39m(t):\n\u001b[0;32m    555\u001b[0m   \u001b[38;5;66;03m# Don't turn ragged or sparse tensors to NumPy.\u001b[39;00m\n\u001b[0;32m    556\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(t, tf\u001b[38;5;241m.\u001b[39mTensor):\n\u001b[1;32m--> 557\u001b[0m     t \u001b[38;5;241m=\u001b[39m \u001b[43mt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnumpy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    558\u001b[0m   \u001b[38;5;66;03m# Strings, ragged and sparse tensors don't have .item(). Return them as-is.\u001b[39;00m\n\u001b[0;32m    559\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(t, (np\u001b[38;5;241m.\u001b[39mndarray, np\u001b[38;5;241m.\u001b[39mgeneric)):\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\tensorflow\\python\\framework\\ops.py:1223\u001b[0m, in \u001b[0;36m_EagerTensorBase.numpy\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m   1200\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Copy of the contents of this Tensor into a NumPy array or scalar.\u001b[39;00m\n\u001b[0;32m   1201\u001b[0m \n\u001b[0;32m   1202\u001b[0m \u001b[38;5;124;03mUnlike NumPy arrays, Tensors are immutable, so this method has to copy\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1220\u001b[0m \u001b[38;5;124;03m    NumPy dtype.\u001b[39;00m\n\u001b[0;32m   1221\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m   1222\u001b[0m \u001b[38;5;66;03m# TODO(slebedev): Consider avoiding a copy for non-CPU or remote tensors.\u001b[39;00m\n\u001b[1;32m-> 1223\u001b[0m maybe_arr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_numpy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# pylint: disable=protected-access\u001b[39;00m\n\u001b[0;32m   1224\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m maybe_arr\u001b[38;5;241m.\u001b[39mcopy() \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(maybe_arr, np\u001b[38;5;241m.\u001b[39mndarray) \u001b[38;5;28;01melse\u001b[39;00m maybe_arr\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\tensorflow\\python\\framework\\ops.py:1189\u001b[0m, in \u001b[0;36m_EagerTensorBase._numpy\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m   1187\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_numpy\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m   1188\u001b[0m   \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m-> 1189\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_numpy_internal\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1190\u001b[0m   \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:  \u001b[38;5;66;03m# pylint: disable=protected-access\u001b[39;00m\n\u001b[0;32m   1191\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_status_to_exception(e) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n","\u001b[1;31mKeyboardInterrupt\u001b[0m: "]}],"source":["history_class = LossHistory()\n","\n","callbacks = [\n","    ModelCheckpoint(\"resunet_pp_tversky_a0.5_b0.5_g1.hdf5\", verbose=1, save_best_model=True),\n","    ReduceLROnPlateau(monitor=\"val_loss\", patience=3, factor=0.5, verbose=1),\n","    EarlyStopping(monitor=\"val_loss\", mode='min', patience=6, verbose=1),\n","    TensorBoard(log_dir='logs_resunet_pp_tversky_a0.5_b0.5_g1'),\n","    history_class\n","]\n","\n","resunet_pp_model_history = resunet_pp_model.fit(train_ds,\n","                    steps_per_epoch=train_steps,validation_data=val_ds,\n","                    validation_steps=valid_steps,epochs=epochs,\n","                    callbacks=callbacks,verbose = 1)\n","resunet_pp_model.save('final_resunet_pp_tversky_a0.5_b0.5_g1.hdf5')\n","\n","resunet_pp_hist_df = pd.DataFrame(resunet_pp_model_history.history)\n","\n","hist_csv_file = 'history_resunet_pp_tversky_a0.5_b0.5_g1.csv'\n","with open(hist_csv_file, mode='w') as f:\n","    resunet_pp_hist_df.to_csv(f)"]},{"cell_type":"markdown","metadata":{},"source":["## Визуализация результатов обучения"]},{"cell_type":"code","execution_count":25,"metadata":{},"outputs":[],"source":["# resunet_plus_plus_1 = tf.keras.models.load_model('models/final_resunet_pp_focaltversky_alpha0.7_beta0.3_gamma_1.hdf5', compile=False)\n","# resunet_plus_plus_2 = tf.keras.models.load_model('resunet_pp_focaltversky_alpha0.5_beta0.5_gamma_1_t1.hdf5', compile=False)\n","resunet_plus_plus_3 = tf.keras.models.load_model('models/final_resunet_pp_andreydataset_focaltversky_alpha0.6_beta0.4_gamma_1.hdf5', compile=False)"]},{"cell_type":"code","execution_count":9,"metadata":{},"outputs":[],"source":["# resunet_pp_history1 = pd.read_csv('histories/history_resunet_pp_focaltversky_alpha0.7_beta0.3_gamma_1.csv')\n","# resunet_pp_history2 = pd.read_csv('histories/history_resunet_pp_focaltversky_alpha0.6_beta0.4_gamma_1.csv')\n","resunet_pp_history3 = pd.read_csv('histories/history_resunet_pp_andreydataset_focaltversky_alpha0.6_beta0.4_gamma_1.csv')\n"]},{"cell_type":"code","execution_count":3,"metadata":{},"outputs":[],"source":["def plot_history(history, metrics=[\"one_hot_mean_io_u\", \"val_one_hot_mean_io_u\"], losses=[\"loss\", \"val_loss\"]):\n","    plt.style.use(['tableau-colorblind10'])\n","    plt.figure(figsize=(12, 6))\n","    for metric in metrics:\n","        plt.plot(history[metric], linewidth=3)\n","\n","    plt.suptitle(\"metrics over epochs\", fontsize=20)\n","    plt.ylabel(\"metric\", fontsize=20)\n","    plt.xlabel(\"epoch\", fontsize=20)\n","    plt.legend(metrics, loc=\"center right\", fontsize=15)\n","    plt.show()\n","\n","    plt.figure(figsize=(12, 6))\n","    for loss in losses:\n","        plt.plot(history[loss], linewidth=3)\n","\n","    plt.suptitle(\"loss over epochs\", fontsize=20)\n","    plt.ylabel(\"loss\", fontsize=20)\n","    plt.xlabel(\"epoch\", fontsize=20)\n","    plt.legend(losses, loc=\"center right\", fontsize=15)\n","    plt.show()\n","\n"]},{"cell_type":"markdown","metadata":{},"source":["Графики обучения ResUNet_plus_plus"]},{"cell_type":"code","execution_count":10,"metadata":{},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 1200x600 with 1 Axes>"]},"metadata":{},"output_type":"display_data"},{"data":{"image/png":"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","text/plain":["<Figure size 1200x600 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["plot_history(resunet_pp_history3)"]},{"cell_type":"code","execution_count":20,"metadata":{},"outputs":[{"ename":"RuntimeError","evalue":"You must compile your model before training/testing. Use `model.compile(optimizer, loss)`.","output_type":"error","traceback":["\u001b[1;31m---------------------------------------------------------------------------\u001b[0m","\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)","Cell \u001b[1;32mIn[20], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mresunet_plus_plus_1\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mevaluate\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\utils\\traceback_utils.py:67\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     65\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:  \u001b[38;5;66;03m# pylint: disable=broad-except\u001b[39;00m\n\u001b[0;32m     66\u001b[0m   filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[1;32m---> 67\u001b[0m   \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m     68\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[0;32m     69\u001b[0m   \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\engine\\training.py:3059\u001b[0m, in \u001b[0;36mModel._assert_compile_was_called\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m   3053\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_assert_compile_was_called\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m   3054\u001b[0m   \u001b[38;5;66;03m# Checks whether `compile` has been called. If it has been called,\u001b[39;00m\n\u001b[0;32m   3055\u001b[0m   \u001b[38;5;66;03m# then the optimizer is set. This is different from whether the\u001b[39;00m\n\u001b[0;32m   3056\u001b[0m   \u001b[38;5;66;03m# model is compiled\u001b[39;00m\n\u001b[0;32m   3057\u001b[0m   \u001b[38;5;66;03m# (i.e. whether the model is built and its inputs/outputs are set).\u001b[39;00m\n\u001b[0;32m   3058\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_is_compiled:\n\u001b[1;32m-> 3059\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mYou must compile your model before \u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m   3060\u001b[0m                        \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtraining/testing. \u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m   3061\u001b[0m                        \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mUse `model.compile(optimizer, loss)`.\u001b[39m\u001b[38;5;124m'\u001b[39m)\n","\u001b[1;31mRuntimeError\u001b[0m: You must compile your model before training/testing. Use `model.compile(optimizer, loss)`."]}],"source":["resunet_plus_plus_1.evaluate()"]},{"cell_type":"code","execution_count":21,"metadata":{},"outputs":[],"source":["from tensorflow.keras.utils import to_categorical \n","from sklearn.metrics import ConfusionMatrixDisplay, confusion_matrix"]},{"cell_type":"markdown","metadata":{},"source":["1. TP are on diagonal\n","2. FP are column-wise sums\n","3. FN are row-wise sums"]},{"cell_type":"code","execution_count":22,"metadata":{},"outputs":[],"source":["def calculate_mean_precision_recall(model):\n","    precisions = []\n","    recalls = []\n","    for i in range(len(test_x)):\n","        mask = read_mask(test_y[i])\n","\n","        image = read_image(test_x[i])\n","        image = np.expand_dims(image, axis=0)\n","\n","        prediction = model.predict(image).squeeze()\n","        prediction = np.argmax(prediction, axis=-1).astype(np.int32)\n","\n","        prediction_flattened = prediction.flatten()\n","\n","        mask_flattened = mask.flatten()\n","\n","        cf_matrix = confusion_matrix(mask_flattened, prediction_flattened, normalize='true')\n","\n","        TP = np.diag(cf_matrix)\n","\n","        precision = TP / (np.sum(cf_matrix, axis=0) + 1e-15)\n","        recall = TP / (np.sum(cf_matrix, axis=1) + 1e-15)\n","\n","        precisions.append(precision)\n","        recalls.append(recall)\n","\n","    return np.vstack(precisions).mean(axis=0), np.vstack(recalls).mean(axis=0)"]},{"cell_type":"code","execution_count":27,"metadata":{},"outputs":[{"name":"stderr","output_type":"stream","text":["c:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:386: UserWarning: A single label was found in 'y_true' and 'y_pred'. For the confusion matrix to have the correct shape, use the 'labels' parameter to pass all known labels.\n","  warnings.warn(\n","c:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:386: UserWarning: A single label was found in 'y_true' and 'y_pred'. For the confusion matrix to have the correct shape, use the 'labels' parameter to pass all known labels.\n","  warnings.warn(\n","c:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:386: UserWarning: A single label was found in 'y_true' and 'y_pred'. For the confusion matrix to have the correct shape, use the 'labels' parameter to pass all known labels.\n","  warnings.warn(\n","c:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:386: UserWarning: A single label was found in 'y_true' and 'y_pred'. For the confusion matrix to have the correct shape, use the 'labels' parameter to pass all known labels.\n","  warnings.warn(\n"]},{"ename":"KeyboardInterrupt","evalue":"","output_type":"error","traceback":["\u001b[1;31m---------------------------------------------------------------------------\u001b[0m","\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","Cell \u001b[1;32mIn[27], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m mean_precision, mean_recall \u001b[38;5;241m=\u001b[39m \u001b[43mcalculate_mean_precision_recall\u001b[49m\u001b[43m(\u001b[49m\u001b[43mresunet_plus_plus_3\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(mean_precision, mean_recall)\n","Cell \u001b[1;32mIn[22], line 10\u001b[0m, in \u001b[0;36mcalculate_mean_precision_recall\u001b[1;34m(model)\u001b[0m\n\u001b[0;32m      7\u001b[0m image \u001b[38;5;241m=\u001b[39m read_image(test_x[i])\n\u001b[0;32m      8\u001b[0m image \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mexpand_dims(image, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m---> 10\u001b[0m prediction \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39msqueeze()\n\u001b[0;32m     11\u001b[0m prediction \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39margmax(prediction, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\u001b[38;5;241m.\u001b[39mastype(np\u001b[38;5;241m.\u001b[39mint32)\n\u001b[0;32m     13\u001b[0m prediction_flattened \u001b[38;5;241m=\u001b[39m prediction\u001b[38;5;241m.\u001b[39mflatten()\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\utils\\traceback_utils.py:64\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     62\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m     63\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m---> 64\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m fn(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m     65\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:  \u001b[38;5;66;03m# pylint: disable=broad-except\u001b[39;00m\n\u001b[0;32m     66\u001b[0m   filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\keras\\engine\\training.py:1975\u001b[0m, in \u001b[0;36mModel.predict\u001b[1;34m(self, x, batch_size, verbose, steps, callbacks, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[0;32m   1965\u001b[0m   callbacks \u001b[38;5;241m=\u001b[39m callbacks_module\u001b[38;5;241m.\u001b[39mCallbackList(\n\u001b[0;32m   1966\u001b[0m       callbacks,\n\u001b[0;32m   1967\u001b[0m       add_history\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1971\u001b[0m       epochs\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m,\n\u001b[0;32m   1972\u001b[0m       steps\u001b[38;5;241m=\u001b[39mdata_handler\u001b[38;5;241m.\u001b[39minferred_steps)\n\u001b[0;32m   1974\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpredict_function \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmake_predict_function()\n\u001b[1;32m-> 1975\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_predict_counter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43massign\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1976\u001b[0m callbacks\u001b[38;5;241m.\u001b[39mon_predict_begin()\n\u001b[0;32m   1977\u001b[0m batch_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\tensorflow\\python\\ops\\resource_variable_ops.py:950\u001b[0m, in \u001b[0;36mBaseResourceVariable.assign\u001b[1;34m(self, value, use_locking, name, read_value)\u001b[0m\n\u001b[0;32m    948\u001b[0m   validate_shape \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_shape\u001b[38;5;241m.\u001b[39mis_fully_defined()\n\u001b[0;32m    949\u001b[0m   kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalidate_shape\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m validate_shape\n\u001b[1;32m--> 950\u001b[0m assign_op \u001b[38;5;241m=\u001b[39m gen_resource_variable_ops\u001b[38;5;241m.\u001b[39massign_variable_op(\n\u001b[0;32m    951\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandle, value_tensor, name\u001b[38;5;241m=\u001b[39mname, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    952\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m read_value:\n\u001b[0;32m    953\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lazy_read(assign_op)\n","File \u001b[1;32mc:\\Users\\stepan\\anaconda3\\envs\\py310\\lib\\site-packages\\tensorflow\\python\\ops\\gen_resource_variable_ops.py:141\u001b[0m, in \u001b[0;36massign_variable_op\u001b[1;34m(resource, value, validate_shape, name)\u001b[0m\n\u001b[0;32m    139\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m tld\u001b[38;5;241m.\u001b[39mis_eager:\n\u001b[0;32m    140\u001b[0m   \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 141\u001b[0m     _result \u001b[38;5;241m=\u001b[39m \u001b[43mpywrap_tfe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTFE_Py_FastPathExecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    142\u001b[0m \u001b[43m      \u001b[49m\u001b[43m_ctx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mAssignVariableOp\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mresource\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mvalidate_shape\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m    143\u001b[0m \u001b[43m      \u001b[49m\u001b[43mvalidate_shape\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    144\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m _result\n\u001b[0;32m    145\u001b[0m   \u001b[38;5;28;01mexcept\u001b[39;00m _core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n","\u001b[1;31mKeyboardInterrupt\u001b[0m: "]}],"source":["mean_precision, mean_recall = calculate_mean_precision_recall(resunet_plus_plus_3)\n","print(mean_precision, mean_recall)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# def extract_relevant_slices(nifti_file, margin=30):\n","#     # Load the NIfTI image\n","#     img = nib.load(nifti_file)\n","#     data = img.get_fdata()\n","    \n","#     # Find slices containing liver/tumor\n","#     liver_slices = []\n","#     for i in range(data.shape[2]):\n","#         if np.any(data[:, :, i] > 0):  # Assuming liver/tumor is labeled with positive integers\n","#             liver_slices.append(i)\n","    \n","#     # Determine the range of slices to keep\n","#     min_slice = max(min(liver_slices) - margin, 0)\n","#     max_slice = min(max(liver_slices) + margin, data.shape[2] - 1)\n","    \n","#     # Extract relevant slices\n","#     relevant_data = data[:, :, min_slice:max_slice+1]\n","    \n","#     # Save or process these slices\n","#     return relevant_data\n","\n","# # Example usage\n","# nifti_file = 'path_to_your_nifti_file.nii'\n","# relevant_slices = extract_relevant_slices(nifti_file)"]},{"cell_type":"code","execution_count":25,"metadata":{},"outputs":[],"source":["path_to_images = r\"C:\\Users\\stepan\\ML\\datasets\\130liverscans\\least_dataset\\test\\nii_images\"\n","path_to_masks = r\"C:\\Users\\stepan\\ML\\datasets\\130liverscans\\least_dataset\\test\\nii_masks\""]},{"cell_type":"code","execution_count":27,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["114\n","[44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157]\n","57\n","0 171\n","67\n","[19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85]\n","33\n","0 90\n","115\n","[6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120]\n","57\n","0 124\n","113\n","[39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151]\n","56\n","0 154\n","69\n","[108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176]\n","34\n","74 210\n","73\n","[102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174]\n","36\n","66 210\n","77\n","[132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208]\n","38\n","94 215\n","96\n","[134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229]\n","48\n","86 244\n","37\n","[46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82]\n","18\n","28 88\n","59\n","[77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135]\n","29\n","48 146\n"]}],"source":["import shutil\n","images = os.listdir(path_to_images)\n","masks = os.listdir(path_to_masks)\n","slices = []\n","\n","for i in range(len(images)):\n","    # print(i)\n","    imagepath = os.path.join(path_to_images, images[i])\n","    maskpath = os.path.join(path_to_masks, masks[i])\n","    # print(imagepath, maskpath)\n","    image = nib.load(imagepath).get_fdata()\n","    mask = nib.load(maskpath).get_fdata()\n","    liver_slices = []\n","    for k in range(mask.shape[2]):\n","        if np.any(mask[:, :, k] > 0): \n","            liver_slices.append(k)\n","    n_slices = len(liver_slices)        \n","    \n","    # print(mask.shape)\n","    \n","    print(n_slices)\n","\n","    margin = n_slices // 2\n","    print(liver_slices)\n","    print(margin)\n","    min_slice = max(min(liver_slices) - margin, 0)\n","    max_slice = min(max(liver_slices) + margin, mask.shape[2] - 1)\n","    print(min_slice, max_slice)\n","    # relevant_image_data = image[:, :, min_slice:max_slice+1]\n","    # relevant_mask_data = mask[:, :, min_slice:max_slice+1]\n","    # print(relevant_mask_data.shape[2])\n","    # print((np.arange(min_slice, max_slice + 1).tolist()))\n","    # print(relevant_mask_data.shape)\n","    number = maskpath.split('-')[1].split('.')[0]\n","    mask_slice_path = maskpath.replace(\"\\\\nii_masks\\\\\", \"\\\\masks\\\\\").split('segmentation')[0]\n","    image_slice_path = imagepath.replace(\"\\\\nii_images\\\\\", \"\\\\images\\\\\").split('volume')[0]\n","\n","    # print(mask_slice_path, image_slice_path, number)\n","    for j in range(min_slice, max_slice + 1):\n","        Image.fromarray(np.rot90(mask[:, :, j])).convert('L').save(mask_slice_path + f\"segmentation_{number}_slice_{j}.tiff\")\n","        Image.fromarray(np.rot90(image[:, :, j])).convert('L').save(image_slice_path + f\"volume_{number}_slice_{j}.png\")\n","\n","    # if image.shape[2] < 400:\n","    #     # im = nib.Nifti1Image(image, affine=np.eye(4))\n","    #     im_path = imagepath.replace('volumes', 'volume_less')\n","\n","    #     msk_path = maskpath.replace('segmentations', 'seg_less')\n","    #     shutil.copy(imagepath, im_path)\n","    #     shutil.copy(maskpath, msk_path)\n","\n","    # for j in range(image.shape[2]):\n","        \n","        # Image.fromarray(np.rot90(image[:, :, j])).convert('L').save(f\"C:\\\\Users\\\\stepan\\\\ML\\\\datasets\\\\130liverscans\\\\train\\\\masks\\\\segmentation{i}_slice_{j}.tiff\")\n","    # os.remove(imagepath)"]},{"cell_type":"code","execution_count":29,"metadata":{},"outputs":[{"name":"stderr","output_type":"stream","text":["C:\\Temp\\ipykernel_14164\\2901417238.py:16: RuntimeWarning: overflow encountered in scalar add\n","  class_counts[label] += np.sum(flattened_data == label)\n"]},{"name":"stdout","output_type":"stream","text":["Class 0: 2135468301 pixels\n","Class 1: 332764489 pixels\n","Class 2: 18465194 pixels\n"]}],"source":["def count_pixels_per_class(nifti_files, class_labels):\n","    # Initialize counters for each class\n","    class_counts = {label: 0 for label in class_labels}\n","    \n","    # Iterate through each NIfTI file\n","    for nifti_file in nifti_files:\n","        # Load the NIfTI image\n","        img = nib.load(nifti_file)\n","        data = img.get_fdata()\n","        \n","        # Flatten the image to count pixels across all slices\n","        flattened_data = data.flatten()\n","        \n","        # Count the number of pixels for each class\n","        for label in class_labels:\n","            class_counts[label] += np.sum(flattened_data == label)\n","    \n","    return class_counts\n","\n","# Example usage\n","nifti_folder = path\n","class_labels = [0, 1, 2]  # 0: background, 1: liver, 2: liver tumor\n","\n","# Get a list of all NIfTI files in the folder\n","nifti_files = [os.path.join(nifti_folder, f) for f in os.listdir(nifti_folder) if f.endswith('.nii') or f.endswith('.nii.gz')]\n","\n","# Calculate the pixel counts for each class\n","pixel_counts = count_pixels_per_class(nifti_files, class_labels)\n","\n","# Print the results\n","for label, count in pixel_counts.items():\n","    print(f\"Class {label}: {count} pixels\")"]},{"cell_type":"code","execution_count":44,"metadata":{},"outputs":[{"data":{"text/plain":["0.0075"]},"execution_count":44,"metadata":{},"output_type":"execute_result"}],"source":["18 / 2400"]},{"cell_type":"code","execution_count":16,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["Dataset split completed successfully!\n"]}],"source":["import shutil\n","\n","    \n","volumes_dir = r\"C:\\\\Users\\\\stepan\\\\ML\\\\datasets\\\\130liverscans\\\\volume_less\"\n","masks_dir = r\"C:\\\\Users\\\\stepan\\\\ML\\\\datasets\\\\130liverscans\\\\seg_less\"\n","\n","# Define output directories\n","output_dir = r\"C:\\\\Users\\\\stepan\\\\ML\\\\datasets\\\\130liverscans\\\\least_dataset\"\n","train_images_dir = os.path.join(output_dir, 'train', 'images')\n","train_masks_dir = os.path.join(output_dir, 'train', 'masks')\n","val_images_dir = os.path.join(output_dir, 'val', 'images')\n","val_masks_dir = os.path.join(output_dir, 'val', 'masks')\n","test_images_dir = os.path.join(output_dir, 'test', 'images')\n","test_masks_dir = os.path.join(output_dir, 'test', 'masks')\n","\n","# Create output directories\n","os.makedirs(train_images_dir, exist_ok=True)\n","os.makedirs(train_masks_dir, exist_ok=True)\n","os.makedirs(val_images_dir, exist_ok=True)\n","os.makedirs(val_masks_dir, exist_ok=True)\n","os.makedirs(test_images_dir, exist_ok=True)\n","os.makedirs(test_masks_dir, exist_ok=True)\n","\n","# List all files in volumes and masks directories\n","volumes = sorted(os.listdir(volumes_dir))\n","masks = sorted(os.listdir(masks_dir))\n","\n","# Ensure the lists are the same length and correspond to each other\n","assert len(volumes) == len(masks), \"The number of volumes and masks should be the same\"\n","\n","# Shuffle the files\n","indices = np.arange(len(volumes))\n","np.random.shuffle(indices)\n","\n","volumes = np.array(volumes)[indices]\n","masks = np.array(masks)[indices]\n","\n","# Calculate split sizes\n","total = len(volumes)\n","train_size = int(0.7 * total)\n","val_size = int(0.15 * total)\n","test_size = total - train_size - val_size  # Ensure all items are included\n","\n","# Split the files\n","train_volumes = volumes[:train_size]\n","train_masks = masks[:train_size]\n","\n","val_volumes = volumes[train_size:train_size + val_size]\n","val_masks = masks[train_size:train_size + val_size]\n","\n","test_volumes = volumes[train_size + val_size:]\n","test_masks = masks[train_size + val_size:]\n","\n","# Function to copy files to the respective directories\n","def copy_files(files, source_dir, target_dir):\n","    for file in files:\n","        shutil.copy(os.path.join(source_dir, file), os.path.join(target_dir, file))\n","\n","# Copy files to their respective directories\n","copy_files(train_volumes, volumes_dir, train_images_dir)\n","copy_files(train_masks, masks_dir, train_masks_dir)\n","\n","copy_files(val_volumes, volumes_dir, val_images_dir)\n","copy_files(val_masks, masks_dir, val_masks_dir)\n","\n","copy_files(test_volumes, volumes_dir, test_images_dir)\n","copy_files(test_masks, masks_dir, test_masks_dir)\n","\n","print(\"Dataset split completed successfully!\")"]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.14"}},"nbformat":4,"nbformat_minor":4}