Come addestrare un algoritmo di Machine Learning con tensorflow e keras: un caso d’uso di Cloud Server GPU

In questo articolo vogliamo proiettarvi nel mondo del Machine Learning, un mondo che trova sostanziali benefici dall’utilizzo delle GPU.

Vogliamo farlo tramite un esempio molto interessante e intuitivo che ha come obiettivo quello di addestrare un modello di Machine Learning  (ML) che – data una determinata immagine – permette di catalogarla.

Ricordiamo, prima di calarci nel caso, che Machine Learning o ML è un sottoinsieme dell’intelligenza artificiale che vede i dispositivi in grado di “fare esperienza” e imparare senza essere appositamente programmati, grazie all’automatizzazione della costruzione di modelli analitici. Un esempio concreto di questo auto-apprendimento in cui ci potremmo imbattere spesso? 

Quando per esempio siamo in rete per fare degli acquisti e ci compare la scritta: “Potrebbe interessarti anche il prodotto y”…

Cane o gatto? Lo chiediamo al nostro software

Come può una macchina riconoscere l’elemento rappresentato in una foto? L’essere umano può distinguere per esempio l’immagine di un cane da quella di un gatto grazie alla sua conoscenza ed esperienza, ma una macchina? 

Noi qui vi proponiamo un esperimento alla fine del quale il nostro software sarà in grado di capire se una determinata foto è, appunto, di un cane o di un gatto.

Non ci dilungheremo su aspetti prettamente legati al mondo del ML, ma tratteremo questo esempio com un caso d’uso reale.

Guida alla classificazione di immagini con tensorflow e keras

Andremo a utilizzare due librerie fondamentali Tensorflow e Keras.

Prerequisiti:

– Driver NVIDIA (verificare funzionamento con nvidia-smi)

– NVIDIA cuDNN https://developer.nvidia.com/cudnn

– Python 3

Procediamo con l’installazione delle librerie

pip3 install tensorflow
pip3 install keras
pip3 install matplotlib
pip3 install pydot

yum install graphviz o apt-get install graphviz

Dowload dataset

curl -O https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_3367a.zip

Decomprimere l'archivio

unzip -q kagglecatsanddogs_3367a.zip

Rimuovere eventuali immagini corrotte

import os

num_skipped = 0
for folder_name in ("Cat", "Dog"):
    folder_path = os.path.join("PetImages", folder_name)
    for fname in os.listdir(folder_path):
        fpath = os.path.join(folder_path, fname)
        try:
            fobj = open(fpath, "rb")
            is_jfif = tf.compat.as_bytes("JFIF") in fobj.peek(10)
        finally:
            fobj.close()

        if not is_jfif:
            num_skipped += 1
            # Delete corrupted image
            os.remove(fpath)

print("Deleted %d images" % num_skipped)

Generare il dataset

image_size = (180, 180)
batch_size = 32

train_ds = tf.keras.preprocessing.image_dataset_from_directory(
    "PetImages",
    validation_split=0.2,
    subset="training",
    seed=1337,
    image_size=image_size,
    batch_size=batch_size,
)
val_ds = tf.keras.preprocessing.image_dataset_from_directory(
    "PetImages",
    validation_split=0.2,
    subset="validation",
    seed=1337,
    image_size=image_size,
    batch_size=batch_size,
)

Impostare le opzioni per sfruttare la GPU

inputs = keras.Input(shape=input_shape)
x = data_augmentation(inputs)
x = layers.experimental.preprocessing.Rescaling(1./255)(x)

augmented_train_ds = train_ds.map(
  lambda x, y: (data_augmentation(x, training=True), y))

Configurare il buffer per evitare I/O Asincrono

train_ds = train_ds.prefetch(buffer_size=32)
val_ds = val_ds.prefetch(buffer_size=32)

Costruire il modello

def make_model(input_shape, num_classes):
    inputs = keras.Input(shape=input_shape)
    # Image augmentation block
    x = data_augmentation(inputs)

    # Entry block
    x = layers.experimental.preprocessing.Rescaling(1.0 / 255)(x)
    x = layers.Conv2D(32, 3, strides=2, padding="same")(x)
    x = layers.BatchNormalization()(x)
    x = layers.Activation("relu")(x)

    x = layers.Conv2D(64, 3, padding="same")(x)
    x = layers.BatchNormalization()(x)
    x = layers.Activation("relu")(x)

    previous_block_activation = x  # Set aside residual

    for size in [128, 256, 512, 728]:
        x = layers.Activation("relu")(x)
        x = layers.SeparableConv2D(size, 3, padding="same")(x)
        x = layers.BatchNormalization()(x)

        x = layers.Activation("relu")(x)
        x = layers.SeparableConv2D(size, 3, padding="same")(x)
        x = layers.BatchNormalization()(x)

        x = layers.MaxPooling2D(3, strides=2, padding="same")(x)

        # Project residual
        residual = layers.Conv2D(size, 1, strides=2, padding="same")(
            previous_block_activation
        )
        x = layers.add([x, residual])  # Add back residual
        previous_block_activation = x  # Set aside next residual

    x = layers.SeparableConv2D(1024, 3, padding="same")(x)
    x = layers.BatchNormalization()(x)
    x = layers.Activation("relu")(x)

    x = layers.GlobalAveragePooling2D()(x)
    if num_classes == 2:
        activation = "sigmoid"
        units = 1
    else:
        activation = "softmax"
        units = num_classes

    x = layers.Dropout(0.5)(x)
    outputs = layers.Dense(units, activation=activation)(x)
    return keras.Model(inputs, outputs)


model = make_model(input_shape=image_size + (3,), num_classes=2)
keras.utils.plot_model(model, show_shapes=True)

Allenare il modello

epochs = 50

callbacks = [
    keras.callbacks.ModelCheckpoint("save_at_{epoch}.h5"),
]
model.compile(
    optimizer=keras.optimizers.Adam(1e-3),
    loss="binary_crossentropy",
    metrics=["accuracy"],
)
model.fit(
    train_ds, epochs=epochs, callbacks=callbacks, validation_data=val_ds,
)

Verifica stato running

Salvare il modello

# serialize model to JSON
model_json = model.to_json()
with open("model_001.json", "w") as json_file:    
    json_file.write(model_json)
# serialize weights to HDF5
model.save_weights("model.h5")
print("Saved model to disk")

# load json and create model
json_file = open('model_001.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
model = keras.models.model_from_json(loaded_model_json)
# load weights into new model
model.load_weights("model.h5")
print("Loaded model from disk")

Classificare l’immagine

img = keras.preprocessing.image.load_img(
    "Test_cat.jpg", target_size=image_size
)
img_array = keras.preprocessing.image.img_to_array(img)
img_array = tf.expand_dims(img_array, 0)  # Create batch axis

predictions = model.predict(img_array)
score = predictions[0]
print(
    "This image is %.2f percent cat and %.2f percent dog."
    % (100 * (1 - score), 100 * score)
)

Ecco i risultati.

Codice di esempio (non è implementato il salvataggio e caricamento del modello):

https://github.com/keras-team/keras-io/blob/master/examples/vision/image_classification_from_scratch.py

Il machine learning è più semplice con la potenza dei server GPU

Il riconoscimento degli oggetti è uno dei tanti modi con cui è possibile applicare l’intelligenza artificiale in ambiti molto concreti con risvolti utili alla nostra società.

Pensiamo per esempio al campo medico: grazie al ML e alla Computer Vision, è possibile per esempio analizzare immagini di Tomografia Computerizzata per verificare in modo rapido, immediato, gli effetti del Covid-19 sui polmoni dei pazienti analizzati.

Riuscire a distinguere in pochi secondi da una semplice immagine una normale polmonite da una polmonite da Sars-Cov-2 o, ancor prima, ottenere una diagnosi positiva o negativa al Covid-19 grazie all’intelligenza artificiale è possibile.

Gli ospedali e i centri medici collezionano tantissimi dati e il nostro esperimento con cane e gatto è estendibile a questi ambiti con risultati sorprendenti.

Chiaramente, fare questi tipi di analisi richiede strumenti tecnologici adeguati e in Seeweb siamo a disposizione sia a livello di consulenza che tecnologicamente per supportarti in questo percorso.