Réseau neuronal avec OpenCV 3 et Python 3
introduction
Cette fois, je vais essayer d'apprendre un réseau de neurones en utilisant OpenCV3 et Python3. Le cas de l'utilisation du traitement d'image et du réseau neuronal en combinaison n'est complété qu'avec OpenCV, il est donc pratique pour une petite vérification. De plus, les liaisons Python d'OpenCV sont en fait du C ++, et Python n'est qu'un wrapper qui appelle des méthodes C ++, donc l'apprentissage fonctionne assez rapidement.
■ Environnement d'exécution · Python: 3.5.2 ・ OpenCV: 3.1
■ Cliquez ici pour une installation et une utilisation facile Installer OpenCV 3 (core + contrib) dans l'environnement Python 3 & Différence entre OpenCV 2 et OpenCV 3 & Easy operation check
programme
C'est le programme minimum. Couche d'entrée: 9 Couche cachée: 5 Couche de sortie: 9
Fonction d'activation: sigmoïde Méthode d'apprentissage: propagation arrière Données d'entraînement: ·Des données d'entrée [[1.2, 1.3, 1.9, 2.2, 2.3, 2.9, 3.0, 3.2, 3.3]] ·des données de sortie [[0, 0, 0, 0, 0, 1, 0, 0, 0]] Données de vérification: ·Des données d'entrée [[1.4, 1.5, 1.2, 2.0, 2.5, 2.8, 3.0, 3.1, 3.8]]
ann.py
# -*- coding: utf-8 -*-
import cv2
import numpy as np
#Générer un réseau de neurones
ann = cv2.ml.ANN_MLP_create()
#Couche d'entrée, couche cachée, paramètres de couche de sortie
ann.setLayerSizes(np.array([9, 5, 9], dtype = np.uint8))
#Paramètres de la méthode d'apprentissage
ann.setTrainMethod(cv2.ml.ANN_MLP_BACKPROP)
#Apprentissage
ann.train(np.array([[1.2, 1.3, 1.9, 2.2, 2.3, 2.9, 3.0, 3.2, 3.3]], dtype=np.float32),
cv2.ml.ROW_SAMPLE,
np.array([[0, 0, 0, 0, 0, 1, 0, 0, 0]], dtype=np.float32))
#Vérification
result = ann.predict(np.array([[1.4, 1.5, 1.2, 2.0, 2.5, 2.8, 3.0, 3.1, 3.8]], dtype = np.float32))
print(result)
Résultat d'exécution
Le résultat de l'exécution est le suivant.
(5.0, array([[-0.06419383, -0.13360272, -0.1681568 , -0.18708915, 0.0970564 , 0.89237726, 0.05093023, 0.17537238, 0.13388439]], dtype=float32))
La sortie de l'entrée [[1.4, 1.5, 1.2, 2.0, 2.5, 2.8, 3.0, 3.1, 3.8]] est [[-0.06419383, -0.13360272, -0.1681568, -0.18708915, 0.0970564, 0.89237726, 0.05093023, 0.17537238, 0.13388439]] C'était. Puisque la sortie à entraîner est [[0, 0, 0, 0, 0, 1, 0, 0, 0]], l'entrée au moment de la vérification présente quelques fluctuations par rapport à l'entrée au moment de l'apprentissage. Le résultat de la vérification est compris entre -0,1 et +0,1, ce qui est presque la sortie prévue.
- La première valeur "5.0" du résultat de l'exécution est une valeur sans signification.
Fonction d'activation
La fonction d'activation par défaut est la fonction sigmoïde.
setActivationFunction(type, param1, param2)
Précisez avec.
Exemple de spécification:
activate_function.py
ann.setActivationFunction(cv2.ml.ANN_MLP_SIGMOID_SYM, 0, 0)
| argument | sens | Défaut |
|---|---|---|
| type | Fonction d'activation | Fonction Sigmaid |
| param1 | α | 0 |
| param2 | β | 0 |
| méthode | valeur | constant | Formule |
|---|---|---|---|
| Fonction égale | 0 | cv2.ml.ANN_MLP_IDENTITY | |
| Fonction Sigmaid | 1 | cv2.ml.ANN_MLP_SIGMOID_SYM | |
| Fonction gaussienne | 2 | cv2.ml.ANN_MLP_GAUSSIAN |
- La seule fonction d'activation entièrement prise en charge par OpenCV 3.1.0 est la fonction sigmoïde.
Conditions de sortie
Les paramètres par défaut pour la condition de fin sont à la fois le nombre maximum de répétitions: 1000 et le montant de changement minimum: 0,01.
setTermCriteria(val)
Précisez avec.
Exemple de spécification:
criteria.py
criteria = (cv2.TERM_CRITERIA_MAX_ITER + cv2.TERM_CRITERIA_EPS, 1000, 0.01)
ann.setTermCriteria(criteria)
critères définit les valeurs dans l'ordre de (type, maxCount, epsilon).
・ Type
| constant | sens | valeur |
|---|---|---|
| cv2.TERM_CRITERIA_COUNT | Nombre maximum de répétitions | 1 |
| cv2.TERM_CRITERIA_MAX_ITER | Nombre maximum de répétitions | 1 |
| cv2.TERM_CRITERIA_EPS | Changement minimum | 2 |
- Cv2.TERM_CRITERIA_COUNT et cv2.TERM_CRITERIA_MAX_ITER sont des alias.
Paramètres de propagation arrière
- Coefficient de moment Vous pouvez définir le coefficient de moment pour la différence entre l'itération précédente et l'itération précédente. Si vous définissez cette valeur dans une certaine mesure, vous pouvez l'empêcher de se coincer dans la solution locale et accélérer la convergence. Cependant, si vous le définissez trop grand, il risque de ne pas converger facilement à la fin ou de diverger dans certains cas. En règle générale, environ 0,1 est bon. La valeur par défaut est définie sur 0,1.
Exemple de spécification:
```momentum_scale.py
ann.setBackpropMomentumScale(0.1)
```
- Coefficient d'apprentissage Un coefficient différentiel qui ajuste la vitesse d'apprentissage. S'il est trop petit, il ne convergera pas facilement, et s'il est trop grand, il peut diverger. En règle générale, environ 0,1 est bon. La valeur par défaut est définie sur 0,1.
Exemple de spécification:
```weight_scale.py
ann.setBackpropWeightScale(0.1)
```
- Propagation arrière résiliente OpenCV3 prend en charge la rétropropagation résiliente ainsi que la rétropropagation qui spécifie les deux paramètres ci-dessus. La rétro-propagation résiliente est un algorithme qui modifie le coefficient d'apprentissage selon que le signe du gradient d'apprentissage a changé entre l'instant précédent et cette fois.
- Si le signe est le même la dernière fois et cette fois: Accélérez l'apprentissage en pondérant le gradient d'apprentissage
- Si le signe est différent entre la fois précédente et cette fois: Réduisez le gradient d'apprentissage et approchez-vous de la solution optimale
Cliquez ici pour savoir comment spécifier (lien)
À propos de la relation entre le réseau neuronal à 3 couches et le traitement d'image
Introduction de ** Bag Of Visual Words (BOW) ** dans "Apprendre à classer les chiens et les chats avec OpenCV 3" Cependant, il est bien connu de créer une entrée de réseau neuronal avec BOW. Je voudrais présenter à nouveau ce domaine à une date ultérieure.
Recommended Posts