Сегментация дорог и зданий

import tensorflow as tf
from tensorflow import keras
 
from keras.preprocessing.image import load_img, img_to_array
from keras.models import *
from keras.layers import *
from keras.optimizers import *
from keras.callbacks import *
from keras import backend as keras
 
 
def conv2d_block(input_tensor, n_filters, kernel_size = 3, batchnorm=True):
    # first layer
    x = Conv2D(filters=n_filters, 
               kernel_size=(kernel_size, kernel_size),
               kernel_initializer="he_normal",
               padding="same")(input_tensor)
    
    if batchnorm:
        x = BatchNormalization()(x)
    
    x = Activation("elu")(x)
    
    # second layer
    x = Conv2D(filters=n_filters, 
               kernel_size=(kernel_size, kernel_size),
               kernel_initializer="he_normal",
               padding="same")(x)
    
    if batchnorm:
        x = BatchNormalization()(x)
    x = Activation("relu")(x)
    return x
 
def get_unet(input_channels, output_channels, window_size, n_filters = 4, dropout = 0.5, batchnorm = True, drop = False):
    # contracting path   
    kernel_size = 3
    pool_size = (2, 2)
    
    input_img = Input((window_size, window_size, input_channels), name='img')
    c1 = conv2d_block(input_img, n_filters = n_filters * 1,
                      kernel_size = kernel_size, batchnorm = batchnorm)
    p1 = MaxPooling2D(pool_size) (c1)
    if (drop):
        p1 = Dropout(dropout * 0.5)(p1)
 
    c2 = conv2d_block(p1, n_filters = n_filters * 2, 
                      kernel_size = kernel_size, batchnorm = batchnorm)
    p2 = MaxPooling2D(pool_size) (c2)
    if (drop):
        p2 = Dropout(dropout)(p2)
 
    c3 = conv2d_block(p2, n_filters = n_filters * 4,
                      kernel_size = kernel_size, batchnorm = batchnorm)
    
    p3 = MaxPooling2D(pool_size) (c3)
    if (drop):
        p3 = Dropout(dropout)(p3)
 
    c4 = conv2d_block(p3, n_filters = n_filters * 8,
                      kernel_size = kernel_size, batchnorm = batchnorm)
    
    p4 = MaxPooling2D(pool_size = pool_size) (c4)
    if (drop):
        p4 = Dropout(dropout)(p4)
    
    c5 = conv2d_block(p4, n_filters = n_filters*16,
                      kernel_size = kernel_size, batchnorm = batchnorm)
    
    # expansive path
    u6 = Conv2DTranspose(n_filters*8, (3, 3), 
                         strides = (2, 2), padding='same') (c5)
    
    u6 = concatenate([u6, c4])
    if (drop):
        u6 = Dropout(dropout)(u6)
    c6 = conv2d_block(u6, n_filters = n_filters * 8, 
                      kernel_size = kernel_size, batchnorm = batchnorm)
 
    u7 = Conv2DTranspose(n_filters * 4, (3, 3),
                         strides = (2, 2), padding='same') (c6)
    
    u7 = concatenate([u7, c3])
    if (drop):
        u7 = Dropout(dropout)(u7)
    c7 = conv2d_block(u7, n_filters = n_filters * 4, 
                      kernel_size = kernel_size, batchnorm = batchnorm)
 
    u8 = Conv2DTranspose(n_filters*2, (3, 3),
                         strides = (2, 2), padding = 'same') (c7)
    u8 = concatenate([u8, c2])
    u8 = Dropout(dropout)(u8)
    c8 = conv2d_block(u8, n_filters = n_filters * 2,
                      kernel_size = kernel_size, batchnorm = batchnorm)
 
    u9 = Conv2DTranspose(n_filters*1, (3, 3), 
                         strides = (2, 2), padding = 'same') (c8)
    u9 = concatenate([u9, c1], axis = 3)
    if (drop):
        u9 = Dropout(dropout)(u9)
    c9 = conv2d_block(u9, n_filters = n_filters*1, 
                      kernel_size = kernel_size, batchnorm = batchnorm)
    
    outputs = Conv2D(output_channels, (1, 1), activation = 'sigmoid') (c9)
    model = Model(inputs = [input_img], outputs = [outputs])
    return model

model = get_unet(3, 3, window_size, n_filters = 64, batchnorm = True, drop = False)
model.compile(optimizer = Adam(), loss = "binary_crossentropy",  metrics = ["accuracy"])
 
callbacks = [
    EarlyStopping(patience = 10, verbose = 1),
    ReduceLROnPlateau(factor = 0.1, patience = 20, min_lr = 0.001, verbose = 1),
    ModelCheckpoint(weights_path, verbose = 1, 
    save_best_only = True, save_weights_only = True)
]
 
results = model.fit(X_train, y_train, batch_size = 8,  
                    epochs = 10, callbacks = callbacks,
                    validation_data = (X_valid, y_valid))