Frane con rete DeepLabV3

Aggiornamento

Per usare la GPU T4 sono migrato su Google Colab

Per avere Keras 3 sono state fatte le seguenti modifiche

!pip install keras --upgrade --quiet

!pip install keras-preprocessing==1.0.6

import keras

import os

os.environ["KERAS_BACKEND"] = "tensorflow"

inoltre su Colab non sono riuscito a salvare il modello in .keras o in .hd5.Per questo motivo ho usato il formato dati legacy

tf.saved_model.save(model,"/content/drive/MyDrive/UAV/salvataggio/")

Su Colab sono riuscito a portare il training fino a 25 epochs. Si nota come la T4 sia nettamente superiore al M1

------------------------------------------------------------------------

Nel post precedente avevo trovato che il letteratura i risultati migliori per la segmentazione delle frane e' stati ottenuti con la rete DeepLabV3. 

Ho usato l'esempio a questo link per provare con lo stesso dataset del post precedente. Attenzione, e' necessario utilizzare Keras 3

questo e' il codice leggermente riadattato per puntare alle immagini delle frane

#!/usr/bin/env python

# coding: utf-8

# In[1]:

import keras

from keras import layers

from keras import ops

import os

import numpy as np

from glob import glob

import cv2

from scipy.io import loadmat

import matplotlib.pyplot as plt

# For data preprocessing

get_ipython().system('pip install tensorflow')

from tensorflow import image as tf_image

from tensorflow import data as tf_data

from tensorflow import io as tf_io

# In[2]:

IMAGE_SIZE = 512

BATCH_SIZE = 4

NUM_CLASSES = 2

#DATA_DIR = "./1/instance-level_human_parsing/instance-level_human_parsing/Training"

DATA_DIR = "./UAV"

NUM_TRAIN_IMAGES = 900

NUM_VAL_IMAGES = 100

train_images = sorted(glob(os.path.join(DATA_DIR, "img/*")))[:NUM_TRAIN_IMAGES]

train_masks = sorted(glob(os.path.join(DATA_DIR, "mask/*")))[:NUM_TRAIN_IMAGES]

val_images = sorted(glob(os.path.join(DATA_DIR, "img/*")))[

NUM_TRAIN_IMAGES : NUM_VAL_IMAGES + NUM_TRAIN_IMAGES

]

val_masks = sorted(glob(os.path.join(DATA_DIR, "mask/*")))[

NUM_TRAIN_IMAGES : NUM_VAL_IMAGES + NUM_TRAIN_IMAGES

]

def read_image(image_path, mask=False):

image = tf_io.read_file(image_path)

if mask:

image = tf_image.decode_png(image, channels=1)

image.set_shape([None, None, 1])

image = tf_image.resize(images=image, size=[IMAGE_SIZE, IMAGE_SIZE])

else:

image = tf_image.decode_png(image, channels=3)

image.set_shape([None, None, 3])

image = tf_image.resize(images=image, size=[IMAGE_SIZE, IMAGE_SIZE])

return image

def load_data(image_list, mask_list):

image = read_image(image_list)

mask = read_image(mask_list, mask=True)

return image, mask

def data_generator(image_list, mask_list):

dataset = tf_data.Dataset.from_tensor_slices((image_list, mask_list))

dataset = dataset.map(load_data, num_parallel_calls=tf_data.AUTOTUNE)

dataset = dataset.batch(BATCH_SIZE, drop_remainder=True)

return dataset

train_dataset = data_generator(train_images, train_masks)

val_dataset = data_generator(val_images, val_masks)

print("Train Dataset:", train_dataset)

print("Val Dataset:", val_dataset)

# In[3]:

def convolution_block(

block_input,

num_filters=256,

kernel_size=3,

dilation_rate=1,

use_bias=False,

):

x = layers.Conv2D(

num_filters,

kernel_size=kernel_size,

dilation_rate=dilation_rate,

padding="same",

use_bias=use_bias,

kernel_initializer=keras.initializers.HeNormal(),

)(block_input)

x = layers.BatchNormalization()(x)

return ops.nn.relu(x)

def DilatedSpatialPyramidPooling(dspp_input):

dims = dspp_input.shape

x = layers.AveragePooling2D(pool_size=(dims[-3], dims[-2]))(dspp_input)

x = convolution_block(x, kernel_size=1, use_bias=True)

out_pool = layers.UpSampling2D(

size=(dims[-3] // x.shape[1], dims[-2] // x.shape[2]),

interpolation="bilinear",

)(x)

out_1 = convolution_block(dspp_input, kernel_size=1, dilation_rate=1)

out_6 = convolution_block(dspp_input, kernel_size=3, dilation_rate=6)

out_12 = convolution_block(dspp_input, kernel_size=3, dilation_rate=12)

out_18 = convolution_block(dspp_input, kernel_size=3, dilation_rate=18)

x = layers.Concatenate(axis=-1)([out_pool, out_1, out_6, out_12, out_18])

output = convolution_block(x, kernel_size=1)

return output

# In[4]:

def DeeplabV3Plus(image_size, num_classes):

model_input = keras.Input(shape=(image_size, image_size, 3))

preprocessed = keras.applications.resnet50.preprocess_input(model_input)

resnet50 = keras.applications.ResNet50(

weights="imagenet", include_top=False, input_tensor=preprocessed

)

x = resnet50.get_layer("conv4_block6_2_relu").output

x = DilatedSpatialPyramidPooling(x)

input_a = layers.UpSampling2D(

size=(image_size // 4 // x.shape[1], image_size // 4 // x.shape[2]),

interpolation="bilinear",

)(x)

input_b = resnet50.get_layer("conv2_block3_2_relu").output

input_b = convolution_block(input_b, num_filters=48, kernel_size=1)

x = layers.Concatenate(axis=-1)([input_a, input_b])

x = convolution_block(x)

x = convolution_block(x)

x = layers.UpSampling2D(

size=(image_size // x.shape[1], image_size // x.shape[2]),

interpolation="bilinear",

)(x)

model_output = layers.Conv2D(num_classes, kernel_size=(1, 1), padding="same")(x)

return keras.Model(inputs=model_input, outputs=model_output)

model = DeeplabV3Plus(image_size=IMAGE_SIZE, num_classes=NUM_CLASSES)

model.summary()

# In[5]:

loss = keras.losses.SparseCategoricalCrossentropy(from_logits=True)

model.compile(

optimizer=keras.optimizers.Adam(learning_rate=0.001),

loss=loss,

metrics=["accuracy"],

)

history = model.fit(train_dataset, validation_data=val_dataset, epochs=10)

plt.plot(history.history["loss"])

plt.title("Training Loss")

plt.ylabel("loss")

plt.xlabel("epoch")

plt.show()

plt.plot(history.history["accuracy"])

plt.title("Training Accuracy")

plt.ylabel("accuracy")

plt.xlabel("epoch")

plt.show()

plt.plot(history.history["val_loss"])

plt.title("Validation Loss")

plt.ylabel("val_loss")

plt.xlabel("epoch")

plt.show()

plt.plot(history.history["val_accuracy"])

plt.title("Validation Accuracy")

plt.ylabel("val_accuracy")

plt.xlabel("epoch")

plt.show()

# In[6]:

# Loading the Colormap

colormap = loadmat(

"./1/instance-level_human_parsing/instance-level_human_parsing/human_colormap.mat"

)["colormap"]

colormap = colormap * 100

colormap = colormap.astype(np.uint8)

def infer(model, image_tensor):

predictions = model.predict(np.expand_dims((image_tensor), axis=0))

predictions = np.squeeze(predictions)

predictions = np.argmax(predictions, axis=2)

return predictions

def decode_segmentation_masks(mask, colormap, n_classes):

r = np.zeros_like(mask).astype(np.uint8)

g = np.zeros_like(mask).astype(np.uint8)

b = np.zeros_like(mask).astype(np.uint8)

for l in range(0, n_classes):

idx = mask == l

r[idx] = colormap[l, 0]

g[idx] = colormap[l, 1]

b[idx] = colormap[l, 2]

rgb = np.stack([r, g, b], axis=2)

return rgb

def get_overlay(image, colored_mask):

image = keras.utils.array_to_img(image)

image = np.array(image).astype(np.uint8)

overlay = cv2.addWeighted(image, 0.35, colored_mask, 0.65, 0)

return overlay

def plot_samples_matplotlib(display_list, figsize=(5, 3)):

_, axes = plt.subplots(nrows=1, ncols=len(display_list), figsize=figsize)

for i in range(len(display_list)):

if display_list[i].shape[-1] == 3:

axes[i].imshow(keras.utils.array_to_img(display_list[i]))

else:

axes[i].imshow(display_list[i])

plt.show()

def plot_predictions(images_list, colormap, model):

for image_file in images_list:

image_tensor = read_image(image_file)

prediction_mask = infer(image_tensor=image_tensor, model=model)

prediction_colormap = decode_segmentation_masks(prediction_mask, colormap, 20)

overlay = get_overlay(image_tensor, prediction_colormap)

plot_samples_matplotlib(

[image_tensor, overlay, prediction_colormap], figsize=(18, 14)

)

# In[7]:

plot_predictions(train_images[:4], colormap, model=model)

# ### Inference on Validation Images

#

# You can use the trained model hosted on [Hugging Face Hub](https://huggingface.co/keras-io/deeplabv3p-resnet50)

# and try the demo on [Hugging Face Spaces](https://huggingface.co/spaces/keras-io/Human-Part-Segmentation).

# In[8]:

plot_predictions(val_images[:4], colormap, model=model)

# In[12]:

get_ipython().system('pip install ipython')

get_ipython().system('mkdir -p saved_model_2')

model.save('saved_model_2/landslide.keras')

Anche su M1 il calcolo e' molto lento....sarebbe stati necessari piu' di 10 epochs per trovare l'asintoto della Loss ma ogni epoch ha impiegato ogni 25 minuti per circa 1000 immagini

in conclusione si vede che le accuracy e' nettamente superiore rispetto a Unet a conferma di quanto riportato in letteratura

Frane da drone con rete UNET

Alla ricerca di immagini di training gia' pronte per reti neurali mi sono imbattuto nel CAS Landslide Database (scaricabile da https://zenodo.org/records/10294997). Sono oltre Gb di immagini tif con immagini di frane sia da satellite che da drone con gia' pronta la maschera della verita' a terra. (avevo gia' provato in questo post)

Il database e' stato oggetto di un articolo di Nature

A questo link viene riportata anche una tabella comparativa di diversi metodi sviluppati sul medesimo dataset

 

Per una prova ho abbondato Colab per installare Tensorflow e Jupyter Notebook su Mac Air M1 e vedere se poteva essere una base di sviluppo. 

conda config --set auto_activate_base false

conda create --name mlp python=3.8 

conda activate mlp   

conda install -c apple tensorflow-deps    

pip install tensorflow-macos   

pip install tensorflow-metal

conda install jupyter pandas numpy matplotlib scikit-learn

jupyter notebook        

Le immagini del dataset Moxitaidi (UAV-0.6m) sono state trasformate in jpg ( magick mogrify -format jpg *.tif) e ridotte 256x256 (mogrify -resize 256x256 *.jpg) tramite imagemagick e sono state rinominate le maschere tramite il comando bash (for f in *.png; do mv "$f" "${f//mask/image}"; done ). Rispetto a quanto provato qui il numero delle epochs e' stato ridotto a 40. M1 si e' comportato egregiamente come velocita' (circa 70 secondi per ogni epoch)

#!/usr/bin/env python

# coding: utf-8

# In[1]:

from functools import partial

import os

import matplotlib.pyplot as plt

import numpy as np

import pandas as pd

import tensorflow as tf

from tensorflow import keras

# In[2]:

images_dir = './UAVjpg256/img/'

masks_dir = './UAVjpg256/mask/'

dirname, _, filenames = next(os.walk(images_dir))

@tf.function

def load_img_with_mask(image_path, images_dir: str = 'img', masks_dir: str = 'label',images_extension: str = 'jpg', masks_extension: str = 'jpg') -> dict:

image = tf.io.read_file(image_path)

image = tf.image.decode_jpeg(image, channels=3)

mask_filename = tf.strings.regex_replace(image_path, images_dir, masks_dir)

mask_filename = tf.strings.regex_replace(mask_filename, images_extension, masks_extension)

mask = tf.io.read_file(mask_filename)

mask = tf.image.decode_image(mask, channels=1, expand_animations = False)

return (image, mask)

n_examples = 3

examples = [load_img_with_mask(os.path.join(images_dir, filenames[i])) for i in range(n_examples)]

fig, axs = plt.subplots(n_examples, 2, figsize=(14, n_examples*7), constrained_layout=True)

for ax, (image, mask) in zip(axs, examples):

ax[0].imshow(image)

ax[1].imshow(mask)

plt.show()

# In[3]:

@tf.function

def resize_images(images, masks, max_image_size=1500):

shape = tf.shape(images)

scale = (tf.reduce_max(shape) // max_image_size) + 1

target_height, target_width = shape[-3] // scale, shape[-2] // scale

images = tf.cast(images, tf.float32)

masks = tf.cast(masks, tf.float32)

if scale != 1:

images = tf.image.resize(images, (target_height, target_width), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)

masks = tf.image.resize(masks, (target_height, target_width), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)

return (images, masks)

@tf.function

def scale_values(images, masks, mask_split_threshold = 128):

images = tf.math.divide(images, 255)

masks = tf.where(masks > mask_split_threshold, 1, 0)

return (images, masks)

@tf.function

def pad_images(images, masks, pad_mul=16, offset=0):

shape = tf.shape(images)

height, width = shape[-3], shape[-2]

target_height = height + tf.math.floormod(tf.math.negative(height), pad_mul)

target_width = width + tf.math.floormod(tf.math.negative(width), pad_mul)

images = tf.image.pad_to_bounding_box(images, offset, offset, target_height, target_width)

masks = tf.cast(tf.image.pad_to_bounding_box(masks, offset, offset, target_height, target_width), tf.uint8)

return (images, masks)

batch_size = 32

test_set_size = 200

validation_set_size = 150

# In[4]:

dataset = tf.data.Dataset.list_files(images_dir + '*.jpg', seed=42)

test_dataset = dataset.take(test_set_size)

dataset = dataset.skip(test_set_size)

test_dataset = test_dataset.map(load_img_with_mask)

test_dataset = test_dataset.map(scale_values)

test_dataset = test_dataset.shuffle(20)

test_dataset = test_dataset.map(lambda img, mask: resize_images(img, mask, max_image_size=2500))

test_dataset = test_dataset.map(pad_images)

test_dataset = test_dataset.batch(1).prefetch(5)

validation_dataset = dataset.take(validation_set_size)

train_dataset = dataset.skip(validation_set_size)

validation_dataset = validation_dataset.map(load_img_with_mask)

validation_dataset = validation_dataset.map(scale_values)

validation_dataset = validation_dataset.shuffle(20)

validation_dataset = validation_dataset.map(resize_images)

validation_dataset = validation_dataset.map(pad_images)

validation_dataset = validation_dataset.batch(1).prefetch(5)

train_dataset = train_dataset.map(load_img_with_mask)

train_dataset = train_dataset.map(scale_values)

train_dataset = train_dataset.shuffle(20)

train_dataset = train_dataset.map(resize_images)

train_dataset = train_dataset.map(pad_images)

train_dataset = train_dataset.batch(1).prefetch(5)

# In[5]:

def get_unet(hidden_activation='relu', initializer='he_normal', output_activation='sigmoid'):

PartialConv = partial(keras.layers.Conv2D,

activation=hidden_activation,

kernel_initializer=initializer,

padding='same')

# Encoder

model_input = keras.layers.Input(shape=(None, None, 3))

enc_cov_1 = PartialConv(32, 3)(model_input)

enc_cov_1 = PartialConv(32, 3)(enc_cov_1)

enc_pool_1 = keras.layers.MaxPooling2D(pool_size=(2, 2))(enc_cov_1)

enc_cov_2 = PartialConv(64, 3)(enc_pool_1)

enc_cov_2 = PartialConv(64, 3)(enc_cov_2)

enc_pool_2 = keras.layers.MaxPooling2D(pool_size=(2, 2))(enc_cov_2)

enc_cov_3 = PartialConv(128, 3)(enc_pool_2)

enc_cov_3 = PartialConv(128, 3)(enc_cov_3)

enc_pool_3 = keras.layers.MaxPooling2D(pool_size=(2, 2))(enc_cov_3)

# Center

center_cov = PartialConv(256, 3)(enc_pool_3)

center_cov = PartialConv(256, 3)(center_cov)

# Decoder

upsampling1 = keras.layers.UpSampling2D(size=(2, 2))(center_cov)

dec_up_conv_1 = PartialConv(128, 2)(upsampling1)

dec_merged_1 = tf.keras.layers.Concatenate(axis=3)([enc_cov_3, dec_up_conv_1])

dec_conv_1 = PartialConv(128, 3)(dec_merged_1)

dec_conv_1 = PartialConv(128, 3)(dec_conv_1)

upsampling2 = keras.layers.UpSampling2D(size=(2, 2))(dec_conv_1)

dec_up_conv_2 = PartialConv(64, 2)(upsampling2)

dec_merged_2 = tf.keras.layers.Concatenate(axis=3)([enc_cov_2, dec_up_conv_2])

dec_conv_2 = PartialConv(64, 3)(dec_merged_2)

dec_conv_2 = PartialConv(64, 3)(dec_conv_2)

upsampling3 = keras.layers.UpSampling2D(size=(2, 2))(dec_conv_2)

dec_up_conv_3 = PartialConv(32, 2)(upsampling3)

dec_merged_3 = tf.keras.layers.Concatenate(axis=3)([enc_cov_1, dec_up_conv_3])

dec_conv_3 = PartialConv(32, 3)(dec_merged_3)

dec_conv_3 = PartialConv(32, 3)(dec_conv_3)

output = keras.layers.Conv2D(1, 1, activation=output_activation)(dec_conv_3)

return tf.keras.Model(inputs=model_input, outputs=output)

model = get_unet()

optimizer = tf.keras.optimizers.Nadam()

model.compile(loss='binary_crossentropy', optimizer=optimizer)

model.summary()

# In[6]:

early_stopping = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=5)

lr_reduce = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.3, patience=3, verbose=1)

epochs = 40

history = model.fit(train_dataset, validation_data=validation_dataset, epochs=epochs, callbacks=[early_stopping, lr_reduce])

# In[7]:

get_ipython().system('mkdir -p saved_model')

model.save('saved_model/landslide_drone')

# In[8]:

converter = tf.lite.TFLiteConverter.from_saved_model('saved_model/landslide_drone')

tflite_model = converter.convert()

with open('model.tflite', 'wb') as f:

f.write(tflite_model)

# In[9]:

n_examples = 10

fig, axs = plt.subplots(n_examples, 3, figsize=(14, n_examples*7), constrained_layout=True)

for ax, ele in zip(axs, test_dataset.take(n_examples)):

image, y_true = ele

prediction = model.predict(image)[0]

prediction = tf.where(prediction > 0.6, 255, 0)

ax[0].set_title('Original image')

ax[0].imshow(image[0])

ax[1].set_title('Original mask')

ax[1].imshow(y_true[0])

ax[2].set_title('Predicted area')

ax[2].imshow(prediction)

plt.show()

# In[10]:

meanIoU = tf.keras.metrics.MeanIoU(num_classes=2)

for ele in test_dataset.take(test_set_size):

image, y_true = ele

prediction = model.predict(image)[0]

prediction = tf.where(prediction > 0.5, 1, 0)

meanIoU.update_state(y_true[0], prediction)

print(meanIoU.result().numpy())

Questi sono due esempi dei risulati