Skip to content

Reti neurali: riconoscimento cifre scritte a mano

Introduzione

Nel contesto dell'analisi dei dati e dell'intelligenza artificiale, il riconoscimento di caratteri scritti a mano è stato (ed è tuttora) un problema affascinante e rilevante. L'obiettivo di questo progetto è sviluppare e addestrare una rete neurale in grado di riconoscere le cifre scritte a mano, sfruttando il famoso dataset MNIST (Modified National Institute of Standards and Technology). MNIST è un insieme di immagini in scala di grigi rappresentanti cifre da 0 a 9 di dimensioni 28x28 pixel, ognuna acquisita da scritture manuali diverse.

Nel corso di questo progetto, utilizzerò la libreria Keras e applicherò tecniche di deep learning per costruire e addestrare una rete neurale per affrontare questa sfida. Le reti neurali sono particolarmente adatte per questo tipo di compito poiché sono in grado di catturare e apprendere gerarchie di caratteristiche dalle immagini in modo efficiente.

Nell'ultima parte del progetto, testerò il modello su 10 immagini di numeri scritti a mano da me.

Fonte dati di addestramento: http://yann.lecun.com/exdb/mnist/ (Invalid URL)

Importazione moduli

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from time import time
import os

from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.utils import to_categorical
from keras.callbacks import History
from keras.regularizers import l2

from skimage import io
from skimage.transform import resize
from skimage.color import rgb2gray

Importazione e preprocessing dei dati

In questa sezione verrà caricato il dataset ed eseguite le operazioni necessarie a trasformare i dati nel formato ottimale per l'addestramento. Nello specifico:

  • Divisione del dataset in sezione di addestramento e sezione di test
  • Reshaping delle features
  • Normalizzazione delle features
  • One-Hot encoding del target

Caricamento del dataset

(X_train, y_train), (X_test, y_test) = mnist.load_data()

display(X_train.shape)
display(X_test.shape)

Reshaping delle features di addestramento e di test e normalizzazione

max_value = max(X_train.flatten())

X_train = X_train.reshape(60000, 28*28) / max_value
X_test = X_test.reshape(10000, 28*28) / max_value

display(X_train.shape)
display(X_test.shape)

Visualizzazione di un esempio contenuto nel dataset

plt.imshow(X_train[12].reshape([28, 28]), cmap='gray')
plt.axis('off')
display(y_train[12])

One-hot encoding delle classi di target

# Trova il numero delle classi di target
num_classes = len(set(y_train))

y_train_dummy = to_categorical(y_train, num_classes)
y_test_dummy = to_categorical(y_test, num_classes)

print("Numero classi:", num_classes)
display(y_train_dummy.shape)
display(y_test_dummy.shape)

# Crea un dataframe con le codifiche
dummies = pd.DataFrame(np.column_stack([y_train, y_train_dummy]), columns=["number", 
                                                                "0", "1", "2", "3", "4", 
                                                                 "5", "6", "7", "8", "9"]).drop_duplicates().set_index("number")
dummies.sort_index(inplace=True)

dummies

Creazione della rete neurale

In questa sezione verrà creata l'architettura della rete neurale. Si tratta di una rete con 3 strati nascosti, rispettivamente di 512, 256 e 128 nodi. Ognuno dei 3 strati utilizzerà la ReLu come funzione di attivazione mentre lo strato di output, trattandosi di un problema di classificazione multipla, utilizzerà la funzione SoftMax.

per ridurre il rischio di overfitting, verranno aggiunti 3 strati di dropout che interesseranno il 50% dei nodi e una regolarizzazione l2 il cui parametro si riduce di 1/10 a ogni strato.

‌
‌
‌