Introduzione

Nel frenetico mondo odierno della consegna di cibo locale, garantire la soddisfazione del cliente è fondamentale per le aziende. Importanti attori come Zomato e Swiggy dominano questo settore. I clienti si aspettano cibo fresco; se ricevono articoli viziati, apprezzano un rimborso o un buono sconto. Tuttavia, determinare manualmente la freschezza degli alimenti è complicato per i clienti e il personale aziendale. Una soluzione è automatizzare questo processo utilizzando modelli di Deep Learning. Questi modelli possono prevedere la freschezza degli alimenti, consentendo ai dipendenti di esaminare solo i reclami segnalati per la convalida finale. Se il modello conferma la freschezza del cibo, può automaticamente respingere il reclamo. In questo articolo costruiremo un rilevatore della qualità degli alimenti utilizzando il Deep Learning.

Il Deep Learning, un sottoinsieme dell’intelligenza artificiale, offre un’utilità significativa in questo contesto. Nello specifico, le CNN (Reti Neurali Convoluzionali) possono essere impiegate per addestrare modelli che utilizzano immagini di cibo per discernere la loro freschezza. L’accuratezza del nostro modello dipende interamente dalla qualità del set di dati. Idealmente, incorporare immagini di cibo reale provenienti dai reclami dei chatbot degli utenti nelle app di consegna di cibo iperlocali migliorerebbe notevolmente la precisione. Tuttavia, non avendo accesso a tali dati, facciamo affidamento su un set di dati ampiamente utilizzato noto come “set di dati di classificazione Fresh and Rotten”, accessibile su Kaggle. Per esplorare il codice completo di deep learning, è sufficiente fare clic sul pulsante "Copia e modifica" fornito qui.

obiettivi formativi

• Scopri l'importanza della qualità del cibo per la soddisfazione del cliente e la crescita del business.
• Scopri come il deep learning aiuta nella costruzione del rilevatore della qualità degli alimenti.
• Acquisisci esperienza pratica attraverso l'implementazione passo passo di questo modello.
• Comprendere le sfide e le soluzioni coinvolte nella sua implementazione.

Questo articolo è stato pubblicato come parte di Blogathon sulla scienza dei dati.

Comprensione dell'uso del Deep Learning nel rilevatore della qualità degli alimenti

Deep Learning, un sottoinsieme di Intelligenza Artificiale, utilizza principalmente set di dati spaziali per costruire modelli. Le reti neurali nell’ambito del Deep Learning vengono utilizzate per addestrare questi modelli, imitando la funzionalità del cervello umano.

Nel contesto del rilevamento della qualità degli alimenti, l’addestramento di modelli di deep learning con ampi set di immagini alimentari è essenziale per distinguere accuratamente tra prodotti alimentari di buona e cattiva qualità. Possiamo farlo messa a punto dell'iperparametro sulla base dei dati forniti, al fine di rendere il modello più accurato. 

Importanza della qualità del cibo nella consegna iperlocale

L'integrazione di questa funzionalità nella consegna di cibo iperlocale offre numerosi vantaggi. Il modello evita pregiudizi nei confronti di clienti specifici e prevede in modo accurato, riducendo così i tempi di risoluzione dei reclami. Inoltre, possiamo utilizzare questa funzione durante il processo di confezionamento degli ordini per ispezionare la qualità degli alimenti prima della consegna, garantendo che i clienti ricevano costantemente cibo fresco.

Sviluppo di un rilevatore della qualità degli alimenti

Per creare completamente questa funzionalità, dobbiamo seguire molti passaggi come ottenere e pulire il set di dati, addestrare il modello di deep learning, valutare le prestazioni ed eseguire l'ottimizzazione degli iperparametri e infine salvare il modello in h5 formato. Successivamente, possiamo implementare il frontend utilizzando Reagiree il backend che utilizza il framework Python django. Utilizzeremo Django per gestire il caricamento delle immagini ed elaborarle. 

Informazioni sul set di dati

Prima di approfondire la preelaborazione dei dati e la creazione del modello, è fondamentale comprendere il set di dati. Come discusso in precedenza, utilizzeremo un set di dati di Kaggle denominato Classificazione degli alimenti freschi e marci. Questo set di dati è suddiviso in due categorie principali denominate Treni ed Test quale vengono utilizzati rispettivamente per scopi di formazione e di test. Sotto la cartella del treno abbiamo 9 sottocartelle di frutta fresca e verdura fresca e 9 sottocartelle di frutta marcia e verdura marcia.

Caratteristiche principali del set di dati

• Varietà di immagini: questo set di dati contiene molte immagini di cibo con molte variazioni in termini di angolazione, sfondo e condizioni di illuminazione. Ciò aiuta il modello a non essere distorto e ad essere più accurato.
• Immagini di alta qualità: questo set di dati contiene immagini di ottima qualità catturate da varie fotocamere professionali.

Caricamento e preparazione dei dati

In questa sezione, caricheremo prima le immagini usando 'tensorflow.keras.preprocessing.immagine.carica_img' funziona e visualizza le immagini utilizzando la libreria matplotlib. La preelaborazione di queste immagini per l'addestramento del modello è davvero importante. Ciò comporta la pulizia e l'organizzazione delle immagini per renderle adatte al modello. 

import os
import matplotlib.pyplot as plt
from tensorflow.keras.preprocessing.image import load_img

def visualize_sample_images(dataset_dir, categories):
    n = len(categories)
    fig, axs = plt.subplots(1, n, figsize=(20, 5))
    for i, category in enumerate(categories):
        folder = os.path.join(dataset_dir, category)
        image_file = os.listdir(folder)[0]
        img_path = os.path.join(folder, image_file)
        img = load_img(img_path)
        axs[i].imshow(img)
        axs[i].set_title(category)
    plt.tight_layout()
    plt.show()

dataset_base_dir = '/kaggle/input/fresh-and-stale-classification/dataset'  
train_dir = os.path.join(dataset_base_dir, 'Train')
categories = ['freshapples', 'rottenapples', 'freshbanana', 'rottenbanana']  
visualize_sample_images(train_dir, categories)

Ora carichiamo le immagini di training e test nelle variabili. Ridimensioneremo tutte le immagini alla stessa altezza e larghezza di 180. 

from tensorflow.keras.preprocessing.image import ImageDataGenerator

batch_size = 32
img_height = 180
img_width = 180

train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=40,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
    fill_mode='nearest',
    validation_split=0.2)  

train_generator = train_datagen.flow_from_directory(
    train_dir,
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='binary',  
    subset='training')

validation_generator = train_datagen.flow_from_directory(
    train_dir,
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='binary',
    subset='validation')

Costruzione del modello

Ora costruiamo il modello di deep learning utilizzando l'algoritmo sequenziale di "tensorflow.keras". Aggiungeremo 3 livelli di convoluzione e un ottimizzatore Adam. Prima di soffermarci sulla parte pratica vediamo innanzitutto quali sono i termini'Modello sequenziale''Adam ottimizzatore', e 'Livello di convoluzione' Significare.

Modello sequenziale

Il modello sequenziale comprende una pila di strati, offrendo una struttura fondamentale in Keras. È ideale per scenari in cui la rete neurale presenta un singolo tensore di input e un singolo tensore di output. Aggiungi i livelli nell'ordine sequenziale di esecuzione, rendendolo adatto alla costruzione di modelli semplici con livelli impilati. Questa semplicità rende il modello sequenziale estremamente utile e più facile da implementare.

Adam ottimizzatore

L'abbreviazione di Adam è "Stima del momento adattivo". Serve come algoritmo di ottimizzazione alternativo alla discesa del gradiente stocastico, aggiornando i pesi della rete in modo iterativo. Adam Optimizer è vantaggioso poiché mantiene un tasso di apprendimento (LR) per ciascun peso di rete, il che è vantaggioso nella gestione del rumore nei dati.

Livello convoluzionale (Conv2D)

È il componente principale delle reti neurali convoluzionali (CNN). Viene utilizzato principalmente per l'elaborazione di set di dati spaziali come le immagini. Questo livello applica una funzione o un'operazione di convoluzione all'input e quindi passa il risultato al livello successivo.

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(img_height, img_width, 3)),
    MaxPooling2D(2, 2),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D(2, 2),
    Conv2D(128, (3, 3), activation='relu'),
    MaxPooling2D(2, 2),
    Flatten(),
    Dense(512, activation='relu'),
    Dropout(0.5),
    Dense(1, activation='sigmoid')  
])

model.compile(optimizer='adam',
              loss='binary_crossentropy',  
              metrics=['accuracy'])

epochs = 10
history = model.fit(
    train_generator,
    steps_per_epoch=train_generator.samples // batch_size,
    epochs=epochs,
    validation_data=validation_generator,
    validation_steps=validation_generator.samples // batch_size)

Test del rilevatore di qualità alimentare

Ora testiamo il modello dandogli una nuova immagine del cibo e vediamo con quanta precisione riesce a classificarlo in cibo fresco e cibo marcio. 

from tensorflow.keras.preprocessing import image
import numpy as np

def classify_image(image_path, model):
    img = image.load_img(image_path, target_size=(img_height, img_width))
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)  
    img_array /= 255.0

    predictions = model.predict(img_array)
    if predictions[0] > 0.5:
        print("Rotten")
    else:
        print("Fresh")


image_path = '/kaggle/input/fresh-and-stale-classification/dataset/Train/
rottenoranges/Screen Shot 2018-06-12 at 11.18.28 PM.png'  
classify_image(image_path, model)

Come possiamo vedere il modello ha previsto correttamente. Come abbiamo dato rottenorange immagine come input come l'ha prevista correttamente il modello Marcio.

Per il codice frontend (React) e backend (Django), puoi vedere il mio codice completo su GitHub qui: Link 

Conclusione

In conclusione, per automatizzare i reclami sulla qualità del cibo nelle app di consegna iperlocale, proponiamo di costruire un modello di deep learning integrato con un'app web. Tuttavia, a causa dei dati di addestramento limitati, il modello potrebbe non rilevare con precisione tutte le immagini degli alimenti. Questa implementazione costituisce un passo fondamentale verso una soluzione più ampia. L’accesso in tempo reale alle immagini caricate dagli utenti all’interno di queste app migliorerebbe significativamente la precisione del nostro modello.

Punti chiave

• La qualità del cibo svolge un ruolo fondamentale nel raggiungimento della soddisfazione del cliente nel mercato della consegna di cibo iperlocale.
• Puoi utilizzare la tecnologia Deep Learning per addestrare un predittore accurato della qualità del cibo.
• Hai acquisito esperienza pratica con questa guida passo passo per creare l'app Web.
• Hai compreso l'importanza della qualità del set di dati per costruire un modello accurato.

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell'autore.

• Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
• PlatoData.Network Generativo verticale Ai. Potenzia te stesso. Accedi qui.
• PlatoAiStream. Intelligenza Web3. Conoscenza amplificata. Accedi qui.
• PlatoneESG. Carbonio, Tecnologia pulita, Energia, Ambiente, Solare, Gestione dei rifiuti. Accedi qui.
• Platone Salute. Intelligence sulle biotecnologie e sulle sperimentazioni cliniche. Accedi qui.
• Fonte: https://www.analyticsvidhya.com/blog/2024/03/food-quality-detector/