Tensorflow segmentazione UNET per frane

Ho trovato su Kaggle questo post in cui si applica la segmentazione tramite rete neurale UNET a corpi idrici

In estrema sintesi al contrario di Yolo la segmentazione non avviene tramite un box attorno all'oggetto di interesse ma tramite una maschera di pixel di forma arbitraria

Funziona per le frane? (ovviamente non sono il primo a pensarci..volevo solo provare). Ho trovata su Kaggle questo dataset in cui sono gia' disponibili le immagini e le maschere (e' un sottoinsieme di un dataset creato per la competizione Landslide4sense 2022 molto piu' voluminoso 3Gb che si trova a questo indirizzo)

Nel dataset ci sono due coppie di immagini. La prima e' un tassello Sentinel 2 truecolor di 128x128 pixel

La seconda una immagine maschera sempre di 128x128 pixel di tipo binario (frana/no frana) realizzata con intervento umano di fotointerpretazione come verita' a terra

La disposizione dei colori e' particolare come si vede dall'istogramma. Ogni colore e' una classe e le classi sono consecutive a partire dal nero. Se si apre il file maschera in Gimp non si vede niente se non si modifica la curva colori

ho applicato, usando Colab e la GPU allegata, lo script per i corpi idrici al dataset delle frane

L'unica modifica che e' ho fatto sul dataset e' stato rinominare le maschere. Il nome del file nella cartella Images deve essere identico a quello della corrispettiva cartella Masks

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

images_dir = 'water/Images'

masks_dir = 'water/Masks'

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

@tf.function

def load_img_with_mask(image_path, images_dir: str = 'Images', masks_dir: str = 'Masks',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()

@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 = 300

validation_set_size = 250

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)

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()

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 = 80

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

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.5, 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()

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 alcuni confronti della validazione con a sinistra l'immagine Sentinel, al centro la maschera fotointerpretata da utente umano ed a destra la maschera di predizione della rete neurale

la accuratezza e' molto buona (forse troppa ...avro' fatto qualche errore?) pari a 0.98

Inferenza TF Lite su CPU e TPU

Per questa prova e' stato selezionato il modello di esempio da questo link riguardante il dataset 900+ birds iNaturalist 2017

 

Per prima cosa c'e' da sottolineare che i modelli per CPU non sono compatibili con le TPU e viceversa. Inoltre l'immagine con cui si vuole fare inferenza deve essere dello stesso tipo (float32,uint8) e delle stesse dimensioni del modello.

CPU

python3 esempio.py --model_file mobilenet_v2_1.0_224_inat_bird_quant.tflite --label_file inat_bird_labels.txt --image ./images/th-1232548430.jpg
 

Risultato

0.831373: Cyanistes caeruleus (Eurasian Blue Tit)
0.027451: Parus major (Great Tit)
0.003922: Coereba flaveola (Bananaquit)
0.003922: Vireo philadelphicus (Philadelphia Vireo)
0.003922: Myiozetetes similis (Social Flycatcher)

 

import argparse

import time

import numpy as np

from PIL import Image

import tensorflow as tf

def load_labels(filename):

with open(filename, 'r') as f:

return [line.strip() for line in f.readlines()]

if __name__ == '__main__':

parser = argparse.ArgumentParser()

parser.add_argument(

'-i',

'--image',

default='/tmp/grace_hopper.bmp',

help='image to be classified')

parser.add_argument(

'-m',

'--model_file',

default='/tmp/mobilenet_v1_1.0_224_quant.tflite',

help='.tflite model to be executed')

parser.add_argument(

'-l',

'--label_file',

default='/tmp/labels.txt',

help='name of file containing labels')

parser.add_argument(

'--input_mean',

default=127.5, type=float,

help='input_mean')

parser.add_argument(

'--input_std',

default=127.5, type=float,

help='input standard deviation')

parser.add_argument(

'--num_threads', default=None, type=int, help='number of threads')

parser.add_argument(

'-e', '--ext_delegate', help='external_delegate_library path')

parser.add_argument(

'-o',

'--ext_delegate_options',

help='external delegate options, \

format: "option1: value1; option2: value2"')

args = parser.parse_args()

ext_delegate = None

ext_delegate_options = {}

# parse extenal delegate options

if args.ext_delegate_options is not None:

options = args.ext_delegate_options.split(';')

for o in options:

kv = o.split(':')

if (len(kv) == 2):

ext_delegate_options[kv[0].strip()] = kv[1].strip()

else:

raise RuntimeError('Error parsing delegate option: ' + o)

# load external delegate

if args.ext_delegate is not None:

print('Loading external delegate from {} with args: {}'.format(

args.ext_delegate, ext_delegate_options))

ext_delegate = [

tflite.load_delegate(args.ext_delegate, ext_delegate_options)

]

interpreter = tf.lite.Interpreter(

model_path=args.model_file,

experimental_delegates=ext_delegate,

num_threads=args.num_threads)

interpreter.allocate_tensors()

input_details = interpreter.get_input_details()

output_details = interpreter.get_output_details()

# check the type of the input tensor

floating_model = input_details[0]['dtype'] == np.float32

# NxHxWxC, H:1, W:2

height = input_details[0]['shape'][1]

width = input_details[0]['shape'][2]

img = Image.open(args.image).resize((width, height))

# add N dim

input_data = np.expand_dims(img, axis=0)

if floating_model:

input_data = (np.float32(input_data) - args.input_mean) / args.input_std

interpreter.set_tensor(input_details[0]['index'], input_data)

start_time = time.time()

interpreter.invoke()

stop_time = time.time()

output_data = interpreter.get_tensor(output_details[0]['index'])

results = np.squeeze(output_data)

top_k = results.argsort()[-5:][::-1]

labels = load_labels(args.label_file)

for i in top_k:

if floating_model:

print('{:08.6f}: {}'.format(float(results[i]), labels[i]))

else:

print('{:08.6f}: {}'.format(float(results[i] / 255.0), labels[i]))

print('time: {:.3f}ms'.format((stop_time - start_time) * 1000))

 

GPU

python3 inferenza.py (attenzione python e basta genera errore su modulo pathlib)

 

Risultato

Cyanistes caeruleus (Eurasian Blue Tit): 0.81250
 

======================================

import os
import pathlib
from pycoral.utils import edgetpu
from pycoral.utils import dataset
from pycoral.adapters import common
from pycoral.adapters import classify
from PIL import Image

# Specify the TensorFlow model, labels, and image
script_dir = pathlib.Path(__file__).parent.absolute()
model_file = os.path.join(script_dir, 'mobilenet_v2_1.0_224_quant_edgetpu.tflite')
label_file = os.path.join(script_dir, 'imagenet_labels.txt')
image_file = os.path.join(script_dir, 'parrot.jpg')

# Initialize the TF interpreter
interpreter = edgetpu.make_interpreter(model_file)
interpreter.allocate_tensors()

# Resize the image
size = common.input_size(interpreter)
image = Image.open(image_file).convert('RGB').resize(size, Image.ANTIALIAS)

# Run an inference
common.set_input(interpreter, image)
interpreter.invoke()
classes = classify.get_classes(interpreter, top_k=1)

# Print the result
labels = dataset.read_label_file(label_file)
for c in classes:
  print('%s: %.5f' % (labels.get(c.id, c.id), c.score)) 

======================================

Decision Tree Tensorflow su dati Sentinel 2

 Ho ripreso il filone di questa prova per provare i Decision Tree con le firme spettrali di Sentinel 2

Per la prova ho preso l'immagine S2B_MSIL2A_20230826T100559_N0509_R022_T32TPP_20230826T134424.SAFE

del periodo estivo del Mugello (Toscana) in modo da avere suolo nudo disponibile.

Visto che volevo estrarre tutte le bande tramite SNAP ho campionato tutte le bande a 10 m (altrimenti come visto nel precedente post lo Spectral Viewer estrae solo le bande native a 10 m)...e qui c'e' un problema...ho dovuto fare il resampling spaziale di tutta l'immagine e dopo fare il subset della mia sola area di interesse altrimenti, invertendo le due operazioni, SNAP entrava continuamente in errore

Usando gli OpenData della Regione Toscana

https://dati.toscana.it/dataset/dbped

ho usato il dataset per selezionare il parametro contenuto in argilla del suolo categorizzandolo a passi del 5%. Usando i Pin e la vista sincronizzata tra la mappe del suolo e l'immagine telerilevata sono selezionati 153 punti appartenenti a 4 classi di contenuto in argilla

Classe/Nr spettri 3 44 2 41 0 34 1 34

Il contenuto in argille delle classi e'

classe 1 (amaranto) : 45-50%

classe 2 (arancione) : 30-35%

classe 3 (rosso) :40-45%

classe 4 (verde) : 20-25%

il file dati in CSV e' formato nel seguente modo

443,490,560,665,705,740,783,842,865,945,1610,2190,Classe

0.0711,0.1056,0.1548,0.2046,0.2335,0.2442,0.2617,0.2624,0.2801,0.2813,0.3556,0.2868,1

0.0777,0.1052,0.157,0.2032,0.2311,0.2415,0.2611,0.2562,0.2741,0.2841,0.3473,0.2829,1

Come si vede dall'esempio la variabilita' spettrale in ogni classe e' molto elevata (in rosso lo spettro medio)

Lo spettro medio per ogni classe di contenuto in argilla e' visualizzato negl grafico sottostante

Usando una rete neurale tradizionale l'accuratezza e ' prossima al 77%

import pandas as pd

import numpy as np

import tensorflow as tf

import seaborn as sns

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense,Dropout

from sklearn.preprocessing import LabelEncoder , StandardScaler

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score, confusion_matrix

df = pd.read_csv('/content/totale2.csv')

print(df.head())

le = LabelEncoder()

df['Classe'] = le.fit_transform(df['Classe'])

X = df.drop(columns=['Classe'])

y = df['Classe']

print(y.head())

print(y.value_counts())

X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.25,shuffle=True,random_state=7)

sc = StandardScaler()

X_train = sc.fit_transform(X_train)

X_test = sc.transform(X_test)

print(X_train.size)

print(y_train)

y_train = tf.keras.utils.to_categorical(y_train,num_classes=4)

def get_models():

    model = Sequential([

        Dense(units=32,input_shape=(12,),activation='relu'),

        Dense(units=32,activation='relu'),

        Dropout(0.5),

        Dense(units=4,activation='softmax')

    ])

    return model

model = get_models()

model.compile(optimizer='Adam',loss='categorical_crossentropy',metrics=['accuracy'])

model.summary()

model.fit(X_train,y_train,epochs=100, verbose=2)

prediction = model.predict(X_test)

prediction = np.argmax(prediction,axis=-1)

acury = accuracy_score(y_test,prediction)

print(acury)

cm = confusion_matrix(y_test,prediction)

print(cm)

0.7692307692307693

Con la seguente matrice di confusione

[[ 4 1 0 0] [ 4 7 0 0] [ 0 0 9 0] [ 1 2 1 10]]

Utilizzando i decision tree

!pip install -q -U tensorflow_decision_forests

!pip install -q -U dtreeviz

import tensorflow_decision_forests as tfdf

import tensorflow as tf

import os

import numpy as np

import pandas as pd

import tensorflow as tf

import math

import dtreeviz

from matplotlib import pyplot as plt

from IPython import display

import logging

logging.getLogger('matplotlib.font_manager').setLevel(level=logging.CRITICAL)

display.set_matplotlib_formats('retina') # generate hires plots

np.random.seed(1234)

def split_dataset(dataset, test_ratio=0.30, seed=1234):

  np.random.seed(seed)

  test_indices = np.random.rand(len(dataset)) < test_ratio

  return dataset[~test_indices], dataset[test_indices]

df_spettri = pd.read_csv("/content/totale2.csv")

df_spettri.head(3)

spettri_label = "Classe"   # Name of the classification target label

classes = list(df_spettri[spettri_label].unique())

df_spettri[spettri_label] = df_spettri[spettri_label].map(classes.index)

print(f"Target '{spettri_label}'' classes: {classes}")

df_spettri.head(3)

# Split into training and test sets

train_ds_pd, test_ds_pd = split_dataset(df_spettri)

print(f"{len(train_ds_pd)} examples in training, {len(test_ds_pd)} examples for testing.")

# Convert to tensorflow data sets

train_ds = tfdf.keras.pd_dataframe_to_tf_dataset(train_ds_pd, label=spettri_label)

test_ds = tfdf.keras.pd_dataframe_to_tf_dataset(test_ds_pd, label=spettri_label)

cmodel = tfdf.keras.RandomForestModel(verbose=0, random_seed=1234)

cmodel.fit(train_ds)

cmodel.compile(metrics=["accuracy"])

cmodel.evaluate(test_ds, return_dict=True, verbose=0)

# Tell dtreeviz about training data and model

spettri_features = [f.name for f in cmodel.make_inspector().features()]

viz_cmodel = dtreeviz.model(cmodel,

                           tree_index=3,

                           X_train=train_ds_pd[spettri_features],

                           y_train=train_ds_pd[spettri_label],

                           feature_names=spettri_features,

                           target_name=spettri_label,

                           class_names=classes)

viz_cmodel.view(scale=1.75)

si ha una accuracy di circa 0.7

Coral Mini Dev Board

Primi passi con la Coral Dev Board Mini 

Premessa: e' un dispositivo per sola inferenza con Tensorflow Lite, non puo' fare training di modelli

Per prima cosa si connettono due cavi USB-C. Il primo serve solo per la alimentazione, il secondo solo per la USB-OTG a cui e' collegata la seriale (come al solito screen /dev/TTYACMx 115200)

Sulla scheda e' montata una distro Linux derivata Debian. Per fare lo shutdown in modo pulito da shell si lancia il comando, poi si scollega la seriale e dopo la alimentazione

Di default l'utente e'

user : mendel

password : mendel

e' presente di default il sudo

Ci si puo' collegare via SSH in 192.168.100.2 ma attenzione...di default non e' impostato il login via password, deve essere configurato il servizio da shell seriale prima di accedere in SSH.

Si puo' accedere alla shell anche mediante mdt

Per copiare i file si puo' utilizzare scp oppure mdt push

python -m venv .

source bin/activate

python3 -m pip install mendel-development-toolmdt devices
mdt shell

Lo spazio disco (senza SD Card inserita) di 8Gb cosi' distribuito 

mendel@orange-pig:~$ df -H
Filesystem      Size  Used Avail Use% Mounted on
/dev/root       5.4G  2.0G  3.2G  39% /
devtmpfs        1.1G     0  1.1G   0% /dev
tmpfs           1.1G     0  1.1G   0% /dev/shm
tmpfs           1.1G   18M  1.1G   2% /run
tmpfs           5.3M  4.1k  5.3M   1% /run/lock
tmpfs           1.1G     0  1.1G   0% /sys/fs/cgroup
tmpfs           1.1G  283k  1.1G   1% /var/log
/dev/mmcblk0p3  2.1G   41M  1.9G   3% /home
/dev/mmcblk0p2  130M   29M   95M  24% /boot
tmpfs           210M  4.8M  205M   3% /run/user/1000

per una memoria di 2 Gb

Per connettere Wifi si puo' usare

nmcli dev wifi connect <NETWORK_NAME> password <PASSWORD> ifname wlan0

Attenzione ad APT ..come scritto nel precedente post si devono aggiornare le firme GPG dei repository Google Coral

Attenzione anche alla Camera. Mi sono fatto prestare una camera CSI per Raspberry pensando funzionasse senza problema ma il connettore della Coral e' risultato di molto piu' piccolo della flat della camera. Alla fine ho scoperto che la Coral ha un connettore CSI-2 (24 pin) mentre Raspberry una CSI (15 pin)

Link agli esempi

Camera

Audio

Github

 

 

 

Coral Mini dev board e rifiuti su spiaggia

Ho provato ad integrare il modello dei rifiuti su spiaggia visto qui e qui in Tensorflow lite per girare su Coral Mini Dev Board (basato su questo esempio)

Per prima cosa ho scaricato i dati in formato Pascal VOC (quindi con le annotations in formato xml) 

L'albero dei folder e' del tipo

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

dataset

    -train

        --images (solo jpg)

        --annotations (solo xml)

    -test

        --images

        --annotations

    -validation

        --images

        --annotations

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

Per questo motivo ho dovuto dividere i file rispetto al file zip scaricato da roboflow sono xml e jpg sono tutti nello stesso folder

Per fare il retrain ho usato il TF Lite Model Maker . Il problema e' che non ne vuole sapere di girare in Colab ed ho tirato su un Docker con il seguente Dockerfile

Inoltre TF Lite Model Maker effettua il retrain di modelli destinati a funzionare on edge e su mobile, in particolare usando EffiecientDet Lite 

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

FROM tensorflow/tensorflow:2.13.0-gpu

RUN apt-get update && \
    apt-get install -y libusb-1.0-0 libusb-1.0-0-dev

RUN pip install tflite-model-maker
RUN pip install pycocotools 

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

lanciandolo con il comando

docker build -t litegpu .

docker run --gpus all -it -p  -v $PWD:/tmp -w /tmp litegpu bash

A questo punto si passa alla creazione vera e propria del modello con lo script python. Rispetto all'esempio di Colab, ho dovuto abbassare la batch size a 2 e rimuovere la validazione del modello altrimenti lo script satura tutta la memoria GPU

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

import numpy as np
import os

from tflite_model_maker.config import ExportFormat
from tflite_model_maker import model_spec
from tflite_model_maker import object_detector

import tensorflow as tf
assert tf.__version__.startswith('2')

tf.get_logger().setLevel('ERROR')
from absl import logging
logging.set_verbosity(logging.ERROR)


label_map = {1: 'Glass', 2: 'Metal',3: 'Net',4: 'null',5: 'PET_Bottle',6: 'Plastic_Buoy',7: 'Plastic_Buoy_China',8: 'Plastic_ETC',9: 'Rope',10: 'Styrofoam_Box',11: 'Styrofoam_Buoy',12: 'Styrofoam_Piece'}

train_images_dir = 'dataset/train/images'
train_annotations_dir = 'dataset/train/annotations'
val_images_dir = 'dataset/validation/images'
val_annotations_dir = 'dataset/validation/annotations'
test_images_dir = 'dataset/test/images'
test_annotations_dir = 'dataset/test/annotations'

train_data = object_detector.DataLoader.from_pascal_voc(train_images_dir, train_annotations_dir, label_map=label_map)
validation_data = object_detector.DataLoader.from_pascal_voc(val_images_dir, val_annotations_dir, label_map=label_map)
test_data = object_detector.DataLoader.from_pascal_voc(test_images_dir, test_annotations_dir, label_map=label_map)
print(f'train count: {len(train_data)}')
print(f'validation count: {len(validation_data)}')
print(f'test count: {len(test_data)}')


spec = object_detector.EfficientDetLite0Spec()
model = object_detector.create(train_data=train_data,
                               model_spec=spec,
                               validation_data=validation_data,
                               epochs=10,
                               batch_size=2,
                               train_whole_model=True)
#model.evaluate(test_data)
TFLITE_FILENAME = 'efficientdet-lite-litter.tflite'
LABELS_FILENAME = 'litter-labels.txt'
model.export(export_dir='.', tflite_filename=TFLITE_FILENAME, label_filename=LABELS_FILENAME,
             export_format=[ExportFormat.TFLITE, ExportFormat.LABEL])
model.evaluate_tflite(TFLITE_FILENAME, test_data)

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

con risultato finale

659 - loss: 0.8730 - learning_rate: 2.5257e-05 - gradient_norm: 5.0130 - val_det_loss: 0.6480 - val_cls_loss: 0.3706 - val_box_loss: 0.0055 - val_reg_l2_loss: 0.0659 - val_loss: 0.7139

Si potrebbe anche usare il modello 1 cambiando la linea

spec = object_detector.EfficientDetLite1Spec()

ma la mia scheda grafica non ha abbastanza memoria

Per verificare se il modello funziona si puo' all'interno del docker installare tramite pip

python3 -m pip install --extra-index-url https://google-coral.github.io/py-repo/ pycoral

e poi lanciare il comando lo script

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

from PIL import ImageDraw
from PIL import ImageFont
import PIL

import tflite_runtime.interpreter as tflite
from pycoral.adapters import common
from pycoral.adapters import detect
from pycoral.utils.dataset import read_label_file

def draw_objects(draw, objs, scale_factor, labels):
  """Draws the bounding box and label for each object."""
  COLORS = np.random.randint(0, 255, size=(len(labels), 3), dtype=np.uint8)
  for obj in objs:
    bbox = obj.bbox
    color = tuple(int(c) for c in COLORS[obj.id])
    draw.rectangle([(bbox.xmin * scale_factor, bbox.ymin * scale_factor),
                    (bbox.xmax * scale_factor, bbox.ymax * scale_factor)],
                   outline=color, width=3)
    font = ImageFont.truetype("LiberationSans-Regular.ttf", size=15)
    draw.text((bbox.xmin * scale_factor + 4, bbox.ymin * scale_factor + 4),
              '%s\n%.2f' % (labels.get(obj.id, obj.id), obj.score),
              fill=color, font=font)

# Load the TF Lite model
labels = read_label_file('./e0/litter-labels.txt')
interpreter = tflite.Interpreter('./e0/efficientdet-lite-litter.tflite')
interpreter.allocate_tensors()

# Resize the image for input
image = Image.open('./e0/1.jpg')
_, scale = common.set_resized_input(
    interpreter, image.size, lambda size: image.resize(size, PIL.Image.Resampling.LANCZOS))

# Run inference
interpreter.invoke()
objs = detect.get_objects(interpreter, score_threshold=0.4, image_scale=scale)

# Resize again to a reasonable size for display
display_width = 500
scale_factor = display_width / image.width
height_ratio = image.height / image.width
image = image.resize((display_width, int(display_width * height_ratio)))
draw_objects(ImageDraw.Draw(image), objs, scale_factor, labels)
image.save("output.jpg")

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

il risultato e' l'immagine di apertura del post

A questo punto si compilano i modelli per poter girare su Coral Dev Mini Board installando il compilatore sul PC

wget -O- https://packages.cloud.google.com/apt/doc/apt-key.gpg | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/coral-edgetpu.gpg

apt-get update
apt-get install edgetpu-compiler

e poi lanciando la compilazione con

edgetpu_compiler efficientdet-lite-litter.tflite -d --num_segments=1

a questo punto si copiano i file del modello sulla Dev Board 

scp efficientdet-lite-litter_edgetpu.tflite mendel@192.168.100.2:/home/mendel

e si lancia

python3 detect_image.py --model efficientdet-lite-litter_edgetpu.tflite --labels litter-labels.txt --input CD_10196_jpg.rf.4a2b1adf824f2a18a7eea764b9012f36.jpg --output output.jpg

----INFERENCE TIME----
Note: The first inference is slow because it includes loading the model into Edge TPU memory.
347.37 ms
182.40 ms
181.49 ms
178.24 ms
182.33 ms
-------RESULTS--------
Styrofoam_Piece
  id:     11
  score:  0.453125
  bbox:   BBox(xmin=248, ymin=132, xmax=279, ymax=171)
PET_Bottle
  id:     4
  score:  0.4375
  bbox:   BBox(xmin=274, ymin=206, xmax=299, ymax=246)
 

Attenzione che la versione del runtime del compilatore deve essere compatibile con le librerie sulla Dev Board. In una prima prova avevo avuto l'errore

RuntimeError: Failed to prepare for TPU. Failed precondition: Package requires runtime version (14), which is newer than this runtime version (13).Node number 7 (EdgeTpuDelegateForCustomOp) failed to prepare.

ed infatti il comando  edgetpu_compiler --version rispondeva
Edge TPU Compiler version 16.0.384591198

mentre la runtime version era

python3 -c "import pycoral.utils.edgetpu; print(pycoral.utils.edgetpu.get_runtime_version())"
BuildLabel(COMPILER=6.3.0 20170516,DATE=redacted,TIME=redacted), RuntimeVersion(13)

Questo era dovuto al fatto che apt non scaricava gli aggiornamenti a causa della firma GPG scaduta dei repository Google Coral 

Il problema si e' risolto con

wget -O- https://packages.cloud.google.com/apt/doc/apt-key.gpg | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/coral-edgetpu.gpg

Tensorflow e firme spettrali

Questa e' sola una prova di fattibilita', non ha interesse di uso pratico

Era un po' di tempo che volevo provare ad usare una rete neurale per classificare le firme spettrali da telerilevamento

Per semplicita' ho preso una immagine Sentinel 2 e selezionato 90 Pin sulla mappa (3 categorie: sedimenti fluviali, suolo nudo, vegetazione) per estrarre le firme tramite Optical/Spectrum View

 

C'e' da osservare che SNAP  estrae solo le bande Sentinel 2 a risoluzione a 10 m. Il file csv e' del tipo  (ho provato a fare il resampling per estrarre tutta la firma spettrale mostrata in grafico ma senza successo)

490,560,665,842,Classe
0.0737,0.0992,0.1278,0.2956,1
0.064,0.0882,0.1038,0.2976,1
0.0682,0.0964,0.1086,0.2792,1
0.0674,0.0956,0.1142,0.2832,1
0.0772,0.1046,0.1386,0.2642,1 

 

A questo punto ho modificato questo esempio di tensorflow basato sul dataset Iris sostituendo le feature della morfologia dei fiori con la risposta spettrale

import pandas as pd

import numpy as np

import tensorflow as tf

import seaborn as sns

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense,Dropout

from sklearn.preprocessing import LabelEncoder , StandardScaler

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score, confusion_matrix

df = pd.read_csv('spettri.csv')

print(df.head())

le = LabelEncoder()

df['classe'] = le.fit_transform(df['classe'])

X = df.drop(columns=['classe'])

y = df['classe']

print(y.head())

print(y.value_counts())

X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.25,shuffle=True,random_state=7)

sc = StandardScaler()

X_train = sc.fit_transform(X_train)

X_test = sc.transform(X_test)

print(y_train)

y_train = tf.keras.utils.to_categorical(y_train,num_classes=3)

def get_models():

model = Sequential([

Dense(units=32,input_shape=(4,),activation='relu'),

Dense(units=32,activation='relu'),

Dropout(0.5),

Dense(units=3,activation='softmax')

])

return model

model = get_models()

model.compile(optimizer='Adam',loss='categorical_crossentropy',metrics=['accuracy'])

model.summary()

model.fit(X_train,y_train,epochs=100, verbose=2)

prediction = model.predict(X_test)

prediction = np.argmax(prediction,axis=-1)

acury = accuracy_score(y_test,prediction)

print(acury)

cm = confusion_matrix(y_test,prediction)

print(cm)

In fase di test il perggior riconoscimento e' dell' 86%

Questa e' la matrice di confusione del risultato peggiore
 

[[7 1 0]
 [0 5 2]
 [0 0 8]]