MicroMLP est un perceptron multicouche de micro-réseau neuronal artificiel (principalement utilisé sur les modules ESP32 et Pycom)
Très simple à intégrer et très léger avec un seul fichier :
Fonctionnalités MicroMLP :
- Structure multicouche et connexions modifiable
- Biais intégré sur les neurones
- Plasticité des connexions incluse
- Fonctions d'activation par couche
- Paramètres Alpha, Eta et Gain
- Gestion d’un ensemble d’exemples et apprentissage
- Fonctions QLearning pour utiliser l'apprentissage par renforcement
- Enregistrez et chargez toute la structure vers/depuis le fichier json
- Diverses fonctions d'activation :
- Pas binaire lourd
- Logistique (étape sigmoïde ou douce)
- Tangente hyperbolique
- Redresseur SoftPlus
- ReLU (unité linéaire rectifiée)
- Fonction gaussienne
Utiliser le deep learning pour :
- Traitement du signal (traitement de la parole, identification, filtrage)
- Traitement d'images (compression, reconnaissance, motifs)
- Contrôle (diagnostic, contrôle qualité, robotique)
- Optimisation (planification, régulation du trafic, finance)
- Simulation (simulation boîte noire)
- Classification (analyse ADN)
- Approximation (fonction inconnue, fonction complexe)
Utilisation des fonctions statiques MicroMLP :
| Nom | Fonction |
|---|
| Créer | mlp = MicroMLP.Create(neuronsByLayers, activationFuncName, layersAutoConnectFunction=None, useBiasValue=1.0) |
| ChargerDeFichier | mlp = MicroMLP.LoadFromFile(filename) |
Utilisation de MicroMLP pour créer rapidement un réseau de neurones :
from microMLP import MicroMLP
mlp = MicroMLP . Create ([ 3 , 10 , 2 ], "Sigmoid" , MicroMLP . LayersFullConnect )
Utilisation de la classe principale MicroMLP :
| Nom | Fonction |
|---|
| Constructeur | mlp = MicroMLP() |
| ObtenirCouche | layer = mlp.GetLayer(layerIndex) |
| ObtenirLayerIndex | idx = mlp.GetLayerIndex(layer) |
| Supprimer la couche | mlp.RemoveLayer(layer) |
| GetInputLayer | inputLayer = mlp.GetInputLayer() |
| ObtenirOutputLayer | outputLayer = mlp.GetOutputLayer() |
| Apprendre | ok = mlp.Learn(inputVectorNNValues, targetVectorNNValues) |
| Test | ok = mlp.Test(inputVectorNNValues, targetVectorNNValues) |
| Prédire | outputVectorNNValues = mlp.Predict(inputVectorNNValues) |
| QLearningLearnForChosenAction | ok = mlp.QLearningLearnForChosenAction(stateVectorNNValues, rewardNNValue, pastStateVectorNNValues, chosenActionIndex, terminalState=True, discountFactorNNValue=None) |
| QLearningPredictBestActionIndex | bestActionIndex = mlp.QLearningPredictBestActionIndex(stateVectorNNValues) |
| Enregistrer dans un fichier | ok = mlp.SaveToFile(filename) |
| Ajouter un exemple | ok = mlp.AddExample(inputVectorNNValues, targetVectorNNValues) |
| Exemples clairs | mlp.ClearExamples() |
| Apprendre des exemples | learnCount = mlp.LearnExamples(maxSeconds=30, maxCount=None, stopWhenLearned=True, printMAEAverage=True) |
| Propriété | Exemple | Lire/écrire |
|---|
| Calques | mlp.Layers | obtenir |
| Nombre de couches | mlp.LayersCount | obtenir |
| Est-réseaucomplet | mlp.IsNetworkComplete | obtenir |
| MSE | mlp.MSE | obtenir |
| MAE | mlp.MAE | obtenir |
| MSEPourcentage | mlp.MSEPercent | obtenir |
| MAEPourcentage | mlp.MAEPercent | obtenir |
| ExemplesCount | mlp.ExamplesCount | obtenir |
Utiliser MicroMLP pour apprendre le problème XOr (avec tangente hyperbolique) :
from microMLP import MicroMLP
mlp = MicroMLP . Create ( neuronsByLayers = [ 2 , 2 , 1 ],
activationFuncName = MicroMLP . ACTFUNC_TANH ,
layersAutoConnectFunction = MicroMLP . LayersFullConnect )
nnFalse = MicroMLP . NNValue . FromBool ( False )
nnTrue = MicroMLP . NNValue . FromBool ( True )
mlp . AddExample ( [ nnFalse , nnFalse ], [ nnFalse ] )
mlp . AddExample ( [ nnFalse , nnTrue ], [ nnTrue ] )
mlp . AddExample ( [ nnTrue , nnTrue ], [ nnFalse ] )
mlp . AddExample ( [ nnTrue , nnFalse ], [ nnTrue ] )
learnCount = mlp . LearnExamples ()
print ( "LEARNED :" )
print ( " - False xor False = %s" % mlp . Predict ([ nnFalse , nnFalse ])[ 0 ]. AsBool )
print ( " - False xor True = %s" % mlp . Predict ([ nnFalse , nnTrue ] )[ 0 ]. AsBool )
print ( " - True xor True = %s" % mlp . Predict ([ nnTrue , nnTrue ] )[ 0 ]. AsBool )
print ( " - True xor False = %s" % mlp . Predict ([ nnTrue , nnFalse ])[ 0 ]. AsBool )
if mlp . SaveToFile ( "mlp.json" ) :
print ( "MicroMLP structure saved!" )| Variable | Description | Défaut |
|---|
mlp.Eta | Pondération de la correction d'erreur | 0,30 |
mlp.Alpha | Force des connexions plasticité | 0,75 |
mlp.Gain | Gain d'apprentissage en réseau | 0,99 |
mlp.CorrectLearnedMAE | Seuil d'erreur d'auto-apprentissage | 0,02 |
| Graphique | Nom de la fonction d'activation | Const | Détail |
|---|
 | "Heaviside" | MicroMLP.ACTFUNC_HEAVISIDE | Pas binaire lourd |
 | "Sigmoid" | MicroMLP.ACTFUNC_SIGMOID | Logistique (étape sigmoïde ou douce) |
 | "TanH" | MicroMLP.ACTFUNC_TANH | Tangente hyperbolique |
 | "SoftPlus" | MicroMLP.ACTFUNC_SOFTPLUS | Redresseur SoftPlus |
 | "ReLU" | MicroMLP.ACTFUNC_RELU | Unité linéaire rectifiée |
 | "Gaussian" | MicroMLP.ACTFUNC_GAUSSIAN | Fonction gaussienne |
| Fonction de connexion automatique des couches | Détail |
|---|
MicroMLP.LayersFullConnect | Réseau entièrement connecté |
Utilisation de la classe MicroMLP.Layer :
| Nom | Fonction |
|---|
| Constructeur | layer = MicroMLP.Layer(parentMicroMLP, activationFuncName=None, neuronsCount=0) |
| ObtenirLayerIndex | idx = layer.GetLayerIndex() |
| ObtenirNeuron | neuron = layer.GetNeuron(neuronIndex) |
| ObtenirNeuronIndex | idx = layer.GetNeuronIndex(neuron) |
| Ajouter un neurone | layer.AddNeuron(neuron) |
| SupprimerNeuron | layer.RemoveNeuron(neuron) |
| ObtenirMeanSquareError | mse = layer.GetMeanSquareError() |
| GetMeanAbsoluteError | mae = layer.GetMeanAbsoluteError() |
| GetMeanSquareErrorAsPercent | mseP = layer.GetMeanSquareErrorAsPercent() |
| GetMeanAbsoluteErrorAsPercent | maeP = layer.GetMeanAbsoluteErrorAsPercent() |
| Retirer | layer.Remove() |
| Propriété | Exemple | Lire/écrire |
|---|
| ParentMicroMLP | layer.ParentMicroMLP | obtenir |
| ActivationFuncName | layer.ActivationFuncName | obtenir |
| Neurones | layer.Neurons | obtenir |
| Nombre de neurones | layer.NeuronsCount | obtenir |
Utilisation de la classe MicroMLP.InputLayer(Layer) :
| Nom | Fonction |
|---|
| Constructeur | inputLayer = MicroMLP.InputLayer(parentMicroMLP, neuronsCount=0) |
| SetInputVectorNNValues | ok = inputLayer.SetInputVectorNNValues(inputVectorNNValues) |
Utilisation de la classe MicroMLP.OutputLayer(Layer) :
| Nom | Fonction |
|---|
| Constructeur | outputLayer = MicroMLP.OutputLayer(parentMicroMLP, activationFuncName, neuronsCount=0) |
| GetOutputVectorNNValues | outputVectorNNValues = outputLayer.GetOutputVectorNNValues() |
| ComputeTargetLayerError | ok = outputLayer.ComputeTargetLayerError(targetVectorNNValues) |
Utilisation de la classe MicroMLP.Neuron :
| Nom | Fonction |
|---|
| Constructeur | neuron = MicroMLP.Neuron(parentLayer) |
| ObtenirNeuronIndex | idx = neuron.GetNeuronIndex() |
| GetInputConnections | connections = neuron.GetInputConnections() |
| GetOutputConnections | connections = neuron.GetOutputConnections() |
| AddInputConnection | neuron.AddInputConnection(connection) |
| AddOutputConnection | neuron.AddOutputConnection(connection) |
| SupprimerInputConnection | neuron.RemoveInputConnection(connection) |
| SupprimerOutputConnection | neuron.RemoveOutputConnection(connection) |
| Définir le biais | neuron.SetBias(bias) |
| ObtenirBias | neuron.GetBias() |
| SetOutputNNValue | neuron.SetOutputNNValue(nnvalue) |
| Calculer la valeur | neuron.ComputeValue() |
| Erreur de calcul | neuron.ComputeError(targetNNValue=None) |
| Retirer | neuron.Remove() |
| Propriété | Exemple | Lire/écrire |
|---|
| CoucheParent | neuron.ParentLayer | obtenir |
| Sortie calculée | neuron.ComputedOutput | obtenir |
| Erreur delta calculée | neuron.ComputedDeltaError | obtenir |
| Erreur de signal calculé | neuron.ComputedSignalError | obtenir |
Utilisation de la classe MicroMLP.Connection :
| Nom | Fonction |
|---|
| Constructeur | connection = MicroMLP.Connection(neuronSrc, neuronDst, weight=None) |
| Mettre à jour le poids | connection.UpdateWeight(eta, alpha) |
| Retirer | connection.Remove() |
| Propriété | Exemple | Lire/écrire |
|---|
| NeuroneSrc | connection.NeuronSrc | obtenir |
| NeuroneDst | connection.NeuronDst | obtenir |
| Poids | connection.Weight | obtenir |
Utilisation de la classe MicroMLP.Bias :
| Nom | Fonction |
|---|
| Constructeur | bias = MicroMLP.Bias(neuronDst, value=1.0, weight=None) |
| Mettre à jour le poids | bias.UpdateWeight(eta, alpha) |
| Retirer | bias.Remove() |
| Propriété | Exemple | Lire/écrire |
|---|
| NeuroneDst | bias.NeuronDst | obtenir |
| Valeur | bias.Value | obtenir |
| Poids | bias.Weight | obtenir |
Utilisation des fonctions statiques MicroMLP.NNValue :
| Nom | Fonction |
|---|
| DePourcentage | nnvalue = MicroMLP.NNValue.FromPercent(value) |
| NouveauPourcentage | nnvalue = MicroMLP.NNValue.NewPercent() |
| De l'octet | nnvalue = MicroMLP.NNValue.FromByte(value) |
| Nouvel octet | nnvalue = MicroMLP.NNValue.NewByte() |
| DeBool | nnvalue = MicroMLP.NNValue.FromBool(value) |
| NouveauBool | nnvalue = MicroMLP.NNValue.NewBool() |
| DeAnalogSignal | nnvalue = MicroMLP.NNValue.FromAnalogSignal(value) |
| NouveauSignalAnalogique | nnvalue = MicroMLP.NNValue.NewAnalogSignal() |
Utilisation de la classe MicroMLP.NNValue :
| Nom | Fonction |
|---|
| Constructeur | nnvalue = MicroMLP.NNValue(minValue, maxValue, value) |
| Propriété | Exemple | Lire/écrire |
|---|
| CommeFlotteur | nnvalue.AsFloat = 639.513 | obtenir / définir |
| CommeInt | nnvalue.AsInt = 12345 | obtenir / définir |
| En pourcentage | nnvalue.AsPercent = 65 | obtenir / définir |
| AsByte | nnvalue.AsByte = b'x75' | obtenir / définir |
| CommeBool | nnvalue.AsBool = True | obtenir / définir |
| Comme signal analogique | nnvalue.AsAnalogSignal = 0.39472 | obtenir / définir |
Par JC`zic pour HC² ;')
Rester simple, stupide ?
