Automatic license plate recognition using stochastic gradient descent

(La reconnaissance des plaques d'immatriculation pour la descente de gradient stochastique)

C'est projet une étude comparatif des différents optimizers axés sur la descente de gradient stochastique qui permet d’ajuster le classificateur d’images sous une fonction coût convexe,

Optimizers

Les optimizers a comparé:

• SGD : Stochastic Gradient Descent - a variant of the Gradient Descent algorithm used for optimizing machine learning models.
• Momentum - an optimization algorithm that helps accelerate gradient vectors in the right directions, thus leading to faster converging.
• NAG : Nesterov Accelerated Gradient - a way to give our momentum term a “look ahead” feature.
• AdaGrad - an algorithm for gradient-based optimization that adapts the learning rate to the parameters, performing larger updates for infrequent and smaller updates for frequent parameters.
• RMSprop : Root Mean Square Propagation - an unpublished, adaptive learning rate method proposed by Geoff Hinton.
• Adadelta - an extension of Adagrad that seeks to reduce its aggressive, monotonically decreasing learning rate.
• Adam : Adaptive Moment Estimation - an optimization algorithm that can be used instead of the classical stochastic gradient descent procedure to update network weights iteratively based on training data.
• AdaMax - a variant of Adam based on the infinity norm.

This paper (here) explains more about optimizers.

Le CNN Model

Le CNN Model utilisé ici c’est le VGG16 (et VGG16).

VGG signifie Visual Geometry Group. Il s'agit d'une architecture standard de réseau de neurones à convolution profonde (CNN) à plusieurs couches. Le "profond" fait référence au nombre de couches avec VGG-16 ou VGG-19 consistant respectivement en 16 et 19 couches convolutionnelles. L'architecture VGG est à la base de modèles de reconnaissance d'objets révolutionnaires (this paper here talk more about).

Structure du projet

• Dans le répertoire principale il y a un fichier jupyter notebook license-plate-detection-tfc1.ipynb qui contient les expérimentations de l'entraînement du modèle VGG16 avec l’optimizer Adam.

• Dans le répertoire optimiser_tested il y a les différents jupyter notebook par optimizer.

• Dans sample il y a un tuto sur le création d’un neurone utilisant la descente de gradient. Avec un exemple sur la classification d’images (faire la différence entre un chien et chat sur une image)

Ce projet ne fait pas du OCR (Optical Character Recognition), la reconnaissance de caractère, le modèle n’est pas entraîné pour ça, mais si vous voulez pousser l'expérience plus loin renseignez vous sur OCR python (voir EasyOCR, Tesseract)

Math

Ce projet demande la maîtrise de certain notions mathématique et statistiques (pas obligatoire) :

• Matrices et Vecteurs (une image peut être représenté dans une matrices)
• Convolution d’une matrice
• Convexité
• Dérivée
• Gradient, Hessien, Jacobien
• Régression Linéaire (facultatif: régression logistique)
• Classifiction Linéaire (pas trop mathématique)
• Erreur quadratique moyenne
• Moindres carrés linéaires (facultatif : moindres carrés ordinaires)
• Descente de gradient
• Optimisation stochastique (pour les notions trés avancées)
• Etc.

Install python lib

before install, update pip : pip install --upgrade pip

• tensorflow : pip install tensorflow
• opencv : pip install opencv-python
• sklearn pip install sk-learn
• numpy pip install numpy
• matplotlib pip install matplotlib
• lxml pip install lxml

if you're using Anaconda check this, explain how to install tensorflow on it.

Note : Only the main license-plate-detection-tfc1.py file which is fully commented. Understanding of other files can be inferred from this one.

A short description of the project.

Project Organization

├── LICENSE            <- Open-source license if one is chosen
├── Makefile           <- Makefile with convenience commands like `make data` or `make train`
├── README.md          <- The top-level README for developers using this project.
├── data
│   ├── external       <- Data from third party sources.
│   ├── interim        <- Intermediate data that has been transformed.
│   ├── processed      <- The final, canonical data sets for modeling.
│   └── raw            <- The original, immutable data dump.
│
├── docs               <- A default mkdocs project; see mkdocs.org for details
│
├── models             <- Trained and serialized models, model predictions, or model summaries
│
├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
│                         the creator's initials, and a short `-` delimited description, e.g.
│                         `1.0-jqp-initial-data-exploration`.
│
├── pyproject.toml     <- Project configuration file with package metadata for ml_project_
│                         and configuration for tools like black
│
├── references         <- Data dictionaries, manuals, and all other explanatory materials.
│
├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
│   └── figures        <- Generated graphics and figures to be used in reporting
│
├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
│                         generated with `pip freeze > requirements.txt`
│
├── setup.cfg          <- Configuration file for flake8
│
└── src                <- Source code for use in this project.
    │
    ├── __init__.py    <- Makes ml_project_ a Python module
    │
    ├── data           <- Scripts to download or generate data
    │   └── make_dataset.py
    │
    ├── features       <- Scripts to turn raw data into features for modeling
    │   └── build_features.py
    │
    ├── models         <- Scripts to train models and then use trained models to make
    │   │                 predictions
    │   ├── predict_model.py
    │   └── train_model.py
    │
    └── visualization  <- Scripts to create exploratory and results oriented visualizations
        └── visualize.py