Come migliorare il riconoscimento delle cifre di un modello addestrato su MNIST?

Sto lavorando al riconoscimento a più cifre stampato a mano con Java, usando la OpenCVlibreria per la preelaborazione e la segmentazione, e un Kerasmodello addestrato su MNIST (con una precisione di 0,98) per il riconoscimento.

Il riconoscimento sembra funzionare abbastanza bene, a parte una cosa. La rete abbastanza spesso non riesce a riconoscere quelli (numero "uno"). Non riesco a capire se ciò accade a causa della preelaborazione / implementazione errata della segmentazione o se una rete addestrata su MNIST standard non ha visto il numero uno che assomiglia ai miei casi di test.

Ecco come appaiono le cifre problematiche dopo la preelaborazione e la segmentazione:

diventa ed è classificato come 4.

diventa ed è classificato come 7.

diventa ed è classificato come 4. E così via...

È qualcosa che potrebbe essere risolto migliorando il processo di segmentazione? O meglio migliorando il set di allenamento?

Modifica: migliorare il set di addestramento (aumento dei dati) sarebbe sicuramente di aiuto, cosa che sto già testando, la questione della corretta preelaborazione rimane ancora.

La mia preelaborazione consiste nel ridimensionamento, conversione in scala di grigi, binarizzazione, inversione e dilatazione. Ecco il codice:

Mat resized = new Mat();
Imgproc.resize(image, resized, new Size(), 8, 8, Imgproc.INTER_CUBIC);

Mat grayscale = new Mat();
Imgproc.cvtColor(resized, grayscale, Imgproc.COLOR_BGR2GRAY);

Mat binImg = new Mat(grayscale.size(), CvType.CV_8U);
Imgproc.threshold(grayscale, binImg, 0, 255, Imgproc.THRESH_OTSU);

Mat inverted = new Mat();
Core.bitwise_not(binImg, inverted);

Mat dilated = new Mat(inverted.size(), CvType.CV_8U);
int dilation_size = 5;
Mat kernel = Imgproc.getStructuringElement(Imgproc.CV_SHAPE_CROSS, new Size(dilation_size, dilation_size));
Imgproc.dilate(inverted, dilated, kernel, new Point(-1,-1), 1);

L'immagine preelaborata viene quindi segmentata in singole cifre come segue:

List<Mat> digits = new ArrayList<>();
List<MatOfPoint> contours = new ArrayList<>();
Imgproc.findContours(preprocessed.clone(), contours, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);

// code to sort contours
// code to check that contour is a valid char

List rects = new ArrayList<>();

for (MatOfPoint contour : contours) {
     Rect boundingBox = Imgproc.boundingRect(contour);
     Rect rectCrop = new Rect(boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height);

     rects.add(rectCrop);
}

for (int i = 0; i < rects.size(); i++) {
    Rect x = (Rect) rects.get(i);
    Mat digit = new Mat(preprocessed, x);

    int border = 50;
    Mat result = digit.clone();
    Core.copyMakeBorder(result, result, border, border, border, border, Core.BORDER_CONSTANT, new Scalar(0, 0, 0));

    Imgproc.resize(result, result, new Size(28, 28));
    digits.add(result);
}

Credo che il tuo problema sia il processo di dilatazione. Capisco che desideri normalizzare le dimensioni dell'immagine, ma non dovresti interrompere le proporzioni, dovresti ridimensionare al massimo desiderato di un asse (quello che consente la ridimensionamento più grande senza lasciare che un'altra dimensione dell'asse superi la dimensione massima) e riempire con il colore di sfondo il resto dell'immagine. Non è che "MNIST standard non ha visto il numero uno che assomiglia ai tuoi casi di test", fai apparire le tue immagini come numeri addestrati diversi (quelli che sono riconosciuti)

Se hai mantenuto l'aspetto corretto delle tue immagini (sorgente e post-elaborazione), puoi vedere che non hai solo ridimensionato l'immagine ma "distorta". Può essere il risultato di una dilatazione non omogenea o di un ridimensionamento errato

Sono già state pubblicate alcune risposte, ma nessuna delle due risponde alla tua vera domanda sulla preelaborazione delle immagini .

A mia volta, non vedo problemi significativi con la tua implementazione purché sia ​​un progetto di studio, ben fatto.

Ma una cosa da notare potrebbe mancare. Esistono operazioni di base in morfologia matematica: erosione e dilatazione (usate da te). E ci operazioni complesse: varie combinazioni di quelle di base (es. Apertura e chiusura). Il link Wikipedia non è il miglior riferimento CV, ma puoi iniziare con esso per avere l'idea.

Di solito è meglio usare l' apertura anziché l'erosione e la chiusura anziché la dilatazione poiché in questo caso l'immagine binaria originale cambia molto meno (ma si raggiunge l'effetto desiderato di pulizia di spigoli vivi o riempimento di spazi vuoti). Quindi nel tuo caso dovresti controllare la chiusura (dilatazione dell'immagine seguita da erosione con lo stesso kernel). Nel caso in cui un'immagine extra-piccola 8 * 8 venga notevolmente modificata quando si dilata anche con 1 * 1 kernel (1 pixel è più del 16% dell'immagine) che è meno nelle immagini più grandi).

Per visualizzare l'idea vedi le seguenti immagini (dai tutorial di OpenCV: 1 , 2 ):

dilatazione:

chiusura:

Spero che sia d'aiuto.

Quindi, hai bisogno di un approccio complesso perché ogni fase della tua cascata informatica si basi sui risultati precedenti. Nel tuo algoritmo hai le seguenti funzionalità:

1. Preelaborazione delle immagini

Come accennato in precedenza, se si applica il ridimensionamento, si perdono informazioni sulle proporzioni dell'immagine. Devi fare lo stesso ritrattamento delle immagini delle cifre per ottenere gli stessi risultati impliciti nel processo di addestramento.

Modo migliore se ritagli l'immagine semplicemente con immagini di dimensioni fisse. In quella variante non sarà necessario trovare contorni e ridimensionare l'immagine delle cifre prima del processo di allenamento. Quindi potresti apportare una piccola modifica all'algoritmo di ritaglio per riconoscerlo meglio: è sufficiente trovare il contorno e posizionare la cifra senza ridimensionare al centro della cornice immagine rilevante per il riconoscimento.

Inoltre, dovresti prestare maggiore attenzione all'algoritmo di binarizzazione. Ho avuto esperienza nello studio dell'effetto dei valori soglia di binarizzazione sull'errore di apprendimento: posso dire che questo è un fattore molto significativo. Puoi provare un altro algoritmo di binarizzazione per verificare questa idea. Ad esempio, è possibile utilizzare questa libreria per testare algoritmi di binarizzazione alternativi.

2. Algoritmo di apprendimento

Per migliorare la qualità del riconoscimento, utilizzare la convalida incrociata durante il processo di formazione. Questo ti aiuta a evitare il problema del sovradimensionamento dei dati di allenamento. Ad esempio puoi leggere questo articolo dove è spiegato come usarlo con Keras.

Talvolta tassi più elevati di misurazione dell'accuratezza non dicono nulla sulla reale qualità del riconoscimento, poiché la RNA addestrata non ha trovato il modello nei dati di formazione. Può essere collegato al processo di addestramento o all'insieme di dati di input come spiegato sopra, oppure può essere causato dalla scelta dell'architettura ANN.

3. Architettura ANN

È un grosso problema. Come definire la migliore architettura ANN per risolvere il compito? Non ci sono modi comuni per fare quella cosa. Ma ci sono alcuni modi per avvicinarsi all'ideale. Ad esempio potresti leggere questo libro . Ti aiuta a rendere una visione migliore per il tuo problema. Inoltre puoi trovare qui alcune formule euristiche per adattarsi al numero di strati / elementi nascosti per la tua ANN. Anche qui troverai una piccola panoramica per questo.

Spero che questa volontà aiuti.

Dopo alcune ricerche ed esperimenti, sono giunto alla conclusione che la preelaborazione dell'immagine stessa non era il problema (ho modificato alcuni parametri suggeriti, come ad esempio dimensioni e forma di dilatazione, ma non erano cruciali per i risultati). Ciò che ha aiutato, tuttavia, sono state le seguenti 2 cose:

1. Come notato da @ f4f, dovevo raccogliere il mio set di dati con dati reali. Questo ha già aiutato moltissimo.

2. Ho apportato importanti modifiche alla preelaborazione della segmentazione. Dopo aver ottenuto i contorni individuali, per prima cosa normalizzo le dimensioni per adattarle a una 20x20casella di pixel (così come sono MNIST). Dopodiché centro la scatola nel mezzo 28x28dell'immagine usando il centro di massa (che per le immagini binarie è il valore medio in entrambe le dimensioni).

Naturalmente, ci sono ancora casi di segmentazione difficili, come cifre sovrapposte o connesse, ma le modifiche sopra riportate hanno risposto alla mia domanda iniziale e migliorato le prestazioni della mia classificazione.