Sviluppare Modelli di Riconoscimento delle Immagini con TensorFlow: Utilizzando MobileNetV2
Introduzione
L’Intelligenza Artificiale sta rivoluzionando il mondo dello sviluppo software, e uno dei campi più eccitanti è il riconoscimento delle immagini. TensorFlow, una delle librerie più potenti e flessibili per il machine learning, offre strumenti straordinari per sviluppare modelli di riconoscimento delle immagini. In questa guida, esploreremo come utilizzare un modello pre-addestrato, MobileNetV2, per il riconoscimento delle immagini.
Sezione 1: Preparazione dell’Ambiente di Sviluppo
Installazione di TensorFlow
Per iniziare, assicurati di avere python installato sul tuo sistema. Poi, installa TensorFlow utilizzando pip:
pip install tensorflow
Configurazione degli Strumenti
Per il nostro lavoro, useremo Jupyter Notebook, che puoi installare con:
Avvia Jupyter Notebook con il comando:
jupyter notebook
Sezione 2: Raccolta e Preparazione dei Dati
Dataset di Immagini
Utilizzeremo il dataset CIFAR-10, che contiene 60.000 immagini a colori in 10 classi diverse. Ecco come caricare il dataset:
import tensorflow as tf
from tensorflow.keras.datasets import cifar10
(train_images, train_labels), (test_images, test_labels) = cifar10.load_data()
Preprocessing delle Immagini
Normalizziamo le immagini, ridimensionandole tra 0 e 1:
train_images, test_images = train_images / 255.0, test_images / 255.0
Sezione 3: Utilizzo di MobileNetV2
Caricamento del Modello Pre-addestrato
Utilizziamo MobileNetV2, un modello leggero e potente, pre-addestrato su ImageNet:
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras import layers, models
base_model = MobileNetV2(input_shape=(32, 32, 3),
include_top=False,
weights='imagenet')
base_model.trainable = False
Costruzione del Modello
Aggiungiamo i nostri livelli superiori per adattare MobileNetV2 al nostro dataset:
model = models.Sequential([
base_model,
layers.GlobalAveragePooling2D(),
layers.Dense(10, activation='softmax')
])
Compilazione del Modello
Compiliamo il modello specificando l’optimizer, la loss function e le metriche:
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
Sezione 4: Addestramento e Valutazione del Modello
Training del modello
Addestriamo il modello con i dati di training:
history = model.fit(train_images, train_labels, epochs=10,
validation_data=(test_images, test_labels))
Valutazione delle Prestazioni
Valutiamo il modello sui dati di test
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('\nTest accuracy:', test_acc)
Sezione 5: Ottimizzazione e Miglioramenti
Fine-tuning del Modello
Per migliorare le prestazioni, possiamo sbloccare alcuni strati del modello base e addestrarli:
base_model.trainable = True
model.compile(optimizer=tf.keras.optimizers.Adam(1e-5),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
history_fine = model.fit(train_images, train_labels, epochs=10,
validation_data=(test_images, test_labels))
Sezione 6: Distribuzione del Modello
Salvataggio del Modello
Salviamo il modello per l’uso futuro
model.save('mobilenetv2_cifar10.h5')
Implementazione in un’Applicazione Web
Possiamo creare una semplice API per il nostro modello usando Flask:
from flask import Flask, request, jsonify
import tensorflow as tf
from tensorflow.keras.models import load_model
from PIL import Image
import numpy as np
app = Flask(__name__)
model = load_model('mobilenetv2_cifar10.h5')
def preprocess_image(image, target_size):
image = Image.open(image)
image = image.resize(target_size)
image = np.array(image) / 255.0
image = np.expand_dims(image, axis=0)
return image
@app.route('/predict', methods=['POST'])
def predict():
image = request.files['file']
processed_image = preprocess_image(image, target_size=(32, 32))
prediction = model.predict(processed_image)
return jsonify({'prediction': prediction.tolist()})
if __name__ == '__main__':
app.run(debug=True)
Questo è un esempio base su come utilizzare un modello pre-addestrato, MobileNetV2, per il riconoscimento delle immagini con TensorFlow. Dalla preparazione dei dati all’implementazione del modello in un’applicazione web. Utilizzare i modelli pre-addestrati consente di risparmiare tempo e risorse, ottenendo al contempo prestazioni eccellenti.
Link utili