Classificazione delle immagini di Tensorflow 2.0: installazione, caricamento dei dati, costruzione e addestramento del modello

La classificazione delle immagini è una categoria di riconoscimento dei modelli. Classifica le immagini in base alla relazione tra i pixel vicini. In altre parole, utilizza informazioni contestuali per organizzare le immagini ed è piuttosto popolare tra le diverse tecnologie. È un argomento importante nel Deep Learning e, se lo stai imparando, ti piacerà sicuramente questo articolo.

Qui, eseguiremo la classificazione dell'immagine TensorFlow. Costruiremo un modello, lo addestreremo e quindi miglioreremo la sua precisione per classificare le immagini dei cactus. TensorFlow è una piattaforma di apprendimento automatico open source e un prodotto di Google.

Iniziamo.

Installa TensorFlow 2.0

Innanzitutto, dovrai installare TensorFlow su Google Colab. Puoi installarlo tramite pip:

!pip install tensorflow-gpu==2.0.0-alpha0

Quindi verificheremo l'installazione:

importa flusso tensoriale come tf

print(tf.__versione)

# Uscita: 2.0.0-alpha0

Fonte

Impara: i 5 progetti TensorFlow più popolari per principianti

Caricare dati

Dopo la verifica, possiamo caricare i dati utilizzando il tf.data.dataset. Costruiremo un classificatore che determina se un'immagine contiene un cactus o meno. Il cactus deve essere colonnare. Possiamo usare il set di dati Cactus Aerial Photos per questo scopo. Ora caricheremo i percorsi dei file insieme alle loro etichette:

train_csv = pd.read_csv('data/train.csv')

# Anteponi i nomi dei file di immagine in train/ con relativo percorso

nomifile = ['train/' + fname per fname in train_csv['id'].tolist()]

etichette = train_csv['has_cactus'].tolist()

train_filenames, val_filenames, train_labels, val_labels =

train_test_split(nomi file,

etichette,

dimensione_treno=0.9,

stato_casuale=42)

Una volta che abbiamo le etichette e i nomi dei file, siamo pronti per creare gli oggetti tf.data.Dataset:

train_data = tf.data.Dataset.from_tensor_slices(

(tf.constant(train_filenames), tf.constant(train_labels))

)

val_data = tf.data.Dataset.from_tensor_slices(

(tf.constant(val_filenames), tf.constant(val_labels))

)

Fonte

Al momento, il nostro set di dati non ha le immagini reali. Ha solo i loro nomi di file. Avremo bisogno di una funzione per caricare le immagini necessarie ed elaborarle in modo da poter eseguire il riconoscimento delle immagini TensorFlow su di esse.

IMAGE_SIZE = 96 # Dimensione minima dell'immagine per l'uso con MobileNetV2

LOTTO_DIMENSIONE = 32

# Funzione per caricare e preelaborare ogni immagine

def _parse_fn(nome file, etichetta):

img = tf.io.read_file(img)

img = tf.image.decode_jpeg(img)

img = (tf.cast(img, tf.float32)/127.5) – 1

img = tf.image.resize(img, (IMAGE_SIZE, IMAGE_SIZE))

restituire img, etichetta

# Esegui _parse_fn su ogni esempio nei set di dati train e val

# Anche mischiare e creare batch

train_data = (train_data.map(_parse_fn)

.shuffle(dimensione_buffer=10000)

.batch(BATCH_SIZE)

)

val_data = (val_data.map(_parse_fn)

.shuffle(dimensione_buffer=10000)

.batch(BATCH_SIZE)

)

Fonte

Costruire un modello

In questo esempio di classificazione dell'immagine TensorFlow, creeremo un modello di apprendimento del trasferimento. Questi modelli sono veloci in quanto possono utilizzare modelli di classificazione delle immagini esistenti che sono stati precedentemente sottoposti a formazione. Devono solo riqualificare il livello superiore della loro rete poiché questo livello specifica la classe dell'immagine richiesta.

Utilizzeremo l'API Keras di TensorFlow 2.0 per creare il nostro modello di classificazione delle immagini. E ai fini dell'apprendimento del trasferimento, utilizzeremo MobileNetV2 come rilevatore di attributi. È la seconda versione di MobileNet ed è un prodotto di Google. È più leggero rispetto ad altri modelli come Inception e ResNet e può funzionare su dispositivi mobili. Caricheremo questo modello su ImageNet, congeleremo i pesi, aggiungeremo una testata di classificazione ed eseguirlo senza il suo livello superiore.

FORMA_IMMAGINE = (DIMENSIONE_IMMAGINE, DIMENSIONE_IMMAGINE, 3)

# Modello pre-addestrato con MobileNetV2

base_model = tf.keras.applications.MobileNetV2(

input_shape=IMG_SHAPE,

include_top=Falso,

pesi='imagenet'

)

# Blocca i pesi del modello pre-addestrati

base_model.trainable = Falso

# Testa di classificazione addestrabile

maxpool_layer = tf.keras.layers.GlobalMaxPooling2D()

predict_layer = tf.keras.layers.Dense(1, activation='sigmoid')

# Testa di classificazione degli strati con rilevatore di caratteristiche

modello = tf.keras.Sequential([

modello_base,

maxpool_layer,

previsione_strato

])

learning_rate = 0,0001

# Compila il modello

model.compile(optimizer=tf.keras.optimizers.Adam(lr=learning_rate),

loss='binary_crossentropy',

metriche=['accuratezza']

)

Fonte

Dovresti usare gli ottimizzatori TensorFlow se intendi addestrare modelli tf.keras. Gli ottimizzatori in tf.keras.optimizers e le API tf.train sono insieme in tf.keras.optimizers di TensorFlow 2.0. In TensorFlow 2.0, molti degli ottimizzatori originali di tf.keras hanno ricevuto aggiornamenti e sostituzioni per prestazioni migliori. Ci consentono di applicare ottimizzatori senza compromettere le prestazioni e risparmiare tempo.

Leggi: Tutorial sul rilevamento di oggetti TensorFlow per principianti

Impara i corsi di scienza dei dati dalle migliori università del mondo. Guadagna programmi Executive PG, programmi di certificazione avanzati o programmi di master per accelerare la tua carriera.

Formazione del modello

Dopo aver costruito il modello, possiamo insegnarlo. L'API tf.keras di TensorFlow 2.0 supporta l'API tf.data, quindi è necessario utilizzare gli oggetti tf.data.Dataset per questo scopo. Può eseguire l'allenamento in modo efficiente e non dovremmo scendere a compromessi con le prestazioni.

num_epoche = 30

passi_per_epoca = round(num_treno)//BATCH_SIZE

val_steps = 20

model.fit(train_data.repeat(),

epoche=num_epoche,

passi_per_epoca = passi_per_epoca,

validation_data=val_data.repeat(),

validation_steps=val_steps)

Fonte

Dopo 30 epoche, la precisione del modello aumenta notevolmente, ma possiamo migliorarla ulteriormente. Ricordi, abbiamo menzionato il congelamento dei pesi durante il trasferimento di apprendimento? Bene, ora che abbiamo addestrato il responsabile della classificazione, possiamo sbloccare quei livelli e perfezionare ulteriormente il nostro set di dati:

# Sblocca tutti i livelli di MobileNetV2

base_model.trainable = Vero

# Ricongela i livelli fino a quando i livelli che desideriamo mettere a punto

per il livello in base_model.layers[:100]:

layer.trainable = Falso

# Utilizzare un tasso di apprendimento inferiore

lr_finetune = tasso_di_apprendimento / 10

# Ricompilare il modello

model.compile(loss='binary_crossentropy',

ottimizzatore = tf.keras.optimizers.Adam(lr=lr_finetune),

metriche=['accuratezza'])

# Aumenta le epoche di allenamento per la messa a punto

fine_tune_epochs = 30

total_epochs = num_epochs + fine_tune_epochs

# Perfeziona il modello

# Nota: imposta initial_epoch per iniziare l'allenamento dopo l'epoca 30 da quando abbiamo

# precedentemente addestrato per 30 epoche.

model.fit(train_data.repeat(),

passi_per_epoca = passi_per_epoca,

epochs=totale_epoche,

epoca_iniziale = num_epoche,

validation_data=val_data.repeat(),

validation_steps=val_steps)

Fonte

30 epoche dopo, la precisione del modello migliora ulteriormente. Con più epoche, abbiamo visto un maggiore miglioramento nell'accuratezza del modello. Ora abbiamo un modello di riconoscimento delle immagini TensorFlow adeguato in grado di riconoscere i cactus colonnari nelle immagini con un'elevata precisione.

Leggi anche: Idee per progetti Tensorflow per principianti

Ulteriori informazioni sulla classificazione delle immagini TensorFlow

Le API altamente funzionali di TensorFlow e le sue capacità lo rendono una tecnologia potente da utilizzare per qualsiasi programmatore. Le sue API di alto livello rimuovono anche la sua complessità generale, rendendolo più facile da usare.

Sei interessato a saperne di più su TensorFlow, classificazione delle immagini e argomenti correlati? Quindi ti consigliamo di dare un'occhiata al Diploma PG di IIIT-B e upGrad in Machine Learning e AI che è progettato per i professionisti che lavorano e offre oltre 450 ore di formazione rigorosa, oltre 30 casi di studio e incarichi, stato di Alumni IIIT-B, 5+ pratiche progetti pratici di capstone e assistenza al lavoro con le migliori aziende.