MicroMLP es un perceptrón multicapa de microred neuronal artificial (utilizado principalmente en módulos ESP32 y Pycom)
Muy fácil de integrar y muy ligero con un solo archivo:
Características de MicroMLP:
- Estructura multicapa y conexiones modificable.
- Sesgo integrado en las neuronas.
- Plasticidad de las conexiones incluidas.
- Funciones de activación por capa
- Parámetros Alfa, Eta y Ganancia
- Gestión de un conjunto de ejemplos y aprendizaje.
- Funciones de QLearning para utilizar el aprendizaje por refuerzo
- Guarde y cargue toda la estructura hacia/desde el archivo json
- Varias funciones de activación:
- Paso binario Heaviside
- Logístico (sigmoideo o paso suave)
- Tangente hiperbólica
- Rectificador SoftPlus
- ReLU (unidad lineal rectificada)
- función gaussiana
Utilice el aprendizaje profundo para:
- Procesamiento de señales (procesamiento de voz, identificación, filtrado)
- Procesamiento de imágenes (compresión, reconocimiento, patrones)
- Control (diagnóstico, control de calidad, robótica)
- Optimización (planificación, regulación del tráfico, finanzas)
- Simulación (simulación de caja negra)
- Clasificación (análisis de ADN)
- Aproximación (función desconocida, función compleja)
Usando funciones estáticas de MicroMLP :
| Nombre | Función |
|---|
| Crear | mlp = MicroMLP.Create(neuronsByLayers, activationFuncName, layersAutoConnectFunction=None, useBiasValue=1.0) |
| Cargar desde archivo | mlp = MicroMLP.LoadFromFile(filename) |
El uso de MicroMLP acelera la creación de una red neuronal:
from microMLP import MicroMLP
mlp = MicroMLP . Create ([ 3 , 10 , 2 ], "Sigmoid" , MicroMLP . LayersFullConnect )
Usando la clase principal de MicroMLP :
| Nombre | Función |
|---|
| Constructor | mlp = MicroMLP() |
| Obtener capa | layer = mlp.GetLayer(layerIndex) |
| Obtener índice de capa | idx = mlp.GetLayerIndex(layer) |
| Eliminar capa | mlp.RemoveLayer(layer) |
| Obtener capa de entrada | inputLayer = mlp.GetInputLayer() |
| Obtener capa de salida | outputLayer = mlp.GetOutputLayer() |
| Aprender | ok = mlp.Learn(inputVectorNNValues, targetVectorNNValues) |
| Prueba | ok = mlp.Test(inputVectorNNValues, targetVectorNNValues) |
| Predecir | outputVectorNNValues = mlp.Predict(inputVectorNNValues) |
| QLearningLearnForChosenAction | ok = mlp.QLearningLearnForChosenAction(stateVectorNNValues, rewardNNValue, pastStateVectorNNValues, chosenActionIndex, terminalState=True, discountFactorNNValue=None) |
| QLearningPredictBestActionIndex | bestActionIndex = mlp.QLearningPredictBestActionIndex(stateVectorNNValues) |
| Guardar en archivo | ok = mlp.SaveToFile(filename) |
| Agregar ejemplo | ok = mlp.AddExample(inputVectorNNValues, targetVectorNNValues) |
| ClaroEjemplos | mlp.ClearExamples() |
| AprenderEjemplos | learnCount = mlp.LearnExamples(maxSeconds=30, maxCount=None, stopWhenLearned=True, printMAEAverage=True) |
| Propiedad | Ejemplo | Leer/Escribir |
|---|
| capas | mlp.Layers | conseguir |
| Recuento de capas | mlp.LayersCount | conseguir |
| ¿La red está completa? | mlp.IsNetworkComplete | conseguir |
| MSE | mlp.MSE | conseguir |
| MAE | mlp.MAE | conseguir |
| MSEPorcentaje | mlp.MSEPercent | conseguir |
| MAEPporcentaje | mlp.MAEPercent | conseguir |
| EjemplosContar | mlp.ExamplesCount | conseguir |
Usando MicroMLP para aprender el problema XOr (con tangente hiperbólica):
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 | Descripción | Por defecto |
|---|
mlp.Eta | Ponderación de la corrección de errores | 0,30 |
mlp.Alpha | Fuerza de las conexiones plasticidad. | 0,75 |
mlp.Gain | Ganancia de aprendizaje en red | 0,99 |
mlp.CorrectLearnedMAE | Umbral de error de autoaprendizaje | 0,02 |
| grafo | Nombre de la función de activación | constante | Detalle |
|---|
 | "Heaviside" | MicroMLP.ACTFUNC_HEAVISIDE | Paso binario Heaviside |
 | "Sigmoid" | MicroMLP.ACTFUNC_SIGMOID | Logístico (sigmoideo o paso suave) |
 | "TanH" | MicroMLP.ACTFUNC_TANH | Tangente hiperbólica |
 | "SoftPlus" | MicroMLP.ACTFUNC_SOFTPLUS | Rectificador SoftPlus |
 | "ReLU" | MicroMLP.ACTFUNC_RELU | Unidad lineal rectificada |
 | "Gaussian" | MicroMLP.ACTFUNC_GAUSSIAN | función gaussiana |
| Función de conexión automática de capas | Detalle |
|---|
MicroMLP.LayersFullConnect | Red completamente conectada |
Usando la clase MicroMLP.Layer :
| Nombre | Función |
|---|
| Constructor | layer = MicroMLP.Layer(parentMicroMLP, activationFuncName=None, neuronsCount=0) |
| Obtener índice de capa | idx = layer.GetLayerIndex() |
| ObtenerNeurona | neuron = layer.GetNeuron(neuronIndex) |
| ObtenerNeuronIndex | idx = layer.GetNeuronIndex(neuron) |
| AñadirNeurona | layer.AddNeuron(neuron) |
| QuitarNeurona | layer.RemoveNeuron(neuron) |
| Obtener error cuadrado medio | mse = layer.GetMeanSquareError() |
| Obtener error absoluto medio | mae = layer.GetMeanAbsoluteError() |
| ObtenerMeanSquareErrorAsPercent | mseP = layer.GetMeanSquareErrorAsPercent() |
| ObtenerMeanAbsoluteErrorAsPercent | maeP = layer.GetMeanAbsoluteErrorAsPercent() |
| Eliminar | layer.Remove() |
| Propiedad | Ejemplo | Leer/Escribir |
|---|
| PadreMicroMLP | layer.ParentMicroMLP | conseguir |
| NombreFunciónActivación | layer.ActivationFuncName | conseguir |
| Neuronas | layer.Neurons | conseguir |
| NeuronasCuenta | layer.NeuronsCount | conseguir |
Usando la clase MicroMLP.InputLayer(Layer) :
| Nombre | Función |
|---|
| Constructor | inputLayer = MicroMLP.InputLayer(parentMicroMLP, neuronsCount=0) |
| Establecer valores de entradaVectorNN | ok = inputLayer.SetInputVectorNNValues(inputVectorNNValues) |
Usando la clase MicroMLP.OutputLayer(Layer) :
| Nombre | Función |
|---|
| Constructor | outputLayer = MicroMLP.OutputLayer(parentMicroMLP, activationFuncName, neuronsCount=0) |
| ObtenerOutputVectorNNValues | outputVectorNNValues = outputLayer.GetOutputVectorNNValues() |
| ComputeTargetLayerError | ok = outputLayer.ComputeTargetLayerError(targetVectorNNValues) |
Usando la clase MicroMLP.Neuron :
| Nombre | Función |
|---|
| Constructor | neuron = MicroMLP.Neuron(parentLayer) |
| ObtenerNeuronIndex | idx = neuron.GetNeuronIndex() |
| Obtener conexiones de entrada | connections = neuron.GetInputConnections() |
| Obtener conexiones de salida | connections = neuron.GetOutputConnections() |
| Agregar conexión de entrada | neuron.AddInputConnection(connection) |
| Agregar conexión de salida | neuron.AddOutputConnection(connection) |
| Eliminar conexión de entrada | neuron.RemoveInputConnection(connection) |
| Eliminar conexión de salida | neuron.RemoveOutputConnection(connection) |
| Establecer polarización | neuron.SetBias(bias) |
| ObtenerBias | neuron.GetBias() |
| Establecer valor NN de salida | neuron.SetOutputNNValue(nnvalue) |
| Valor calculado | neuron.ComputeValue() |
| ComputarError | neuron.ComputeError(targetNNValue=None) |
| Eliminar | neuron.Remove() |
| Propiedad | Ejemplo | Leer/Escribir |
|---|
| capa principal | neuron.ParentLayer | conseguir |
| Salida calculada | neuron.ComputedOutput | conseguir |
| Error Delta calculado | neuron.ComputedDeltaError | conseguir |
| Error de señal calculada | neuron.ComputedSignalError | conseguir |
Usando la clase MicroMLP.Connection :
| Nombre | Función |
|---|
| Constructor | connection = MicroMLP.Connection(neuronSrc, neuronDst, weight=None) |
| ActualizarPeso | connection.UpdateWeight(eta, alpha) |
| Eliminar | connection.Remove() |
| Propiedad | Ejemplo | Leer/Escribir |
|---|
| NeuronaSrc | connection.NeuronSrc | conseguir |
| NeuronaDst | connection.NeuronDst | conseguir |
| Peso | connection.Weight | conseguir |
Usando la clase MicroMLP.Bias :
| Nombre | Función |
|---|
| Constructor | bias = MicroMLP.Bias(neuronDst, value=1.0, weight=None) |
| ActualizarPeso | bias.UpdateWeight(eta, alpha) |
| Eliminar | bias.Remove() |
| Propiedad | Ejemplo | Leer/Escribir |
|---|
| NeuronaDst | bias.NeuronDst | conseguir |
| Valor | bias.Value | conseguir |
| Peso | bias.Weight | conseguir |
Usando funciones estáticas MicroMLP.NNValue :
| Nombre | Función |
|---|
| De porcentaje | nnvalue = MicroMLP.NNValue.FromPercent(value) |
| Nuevo porcentaje | nnvalue = MicroMLP.NNValue.NewPercent() |
| DeByte | nnvalue = MicroMLP.NNValue.FromByte(value) |
| nuevo byte | nnvalue = MicroMLP.NNValue.NewByte() |
| DeBool | nnvalue = MicroMLP.NNValue.FromBool(value) |
| NuevoBool | nnvalue = MicroMLP.NNValue.NewBool() |
| De señal analógica | nnvalue = MicroMLP.NNValue.FromAnalogSignal(value) |
| Nueva señal analógica | nnvalue = MicroMLP.NNValue.NewAnalogSignal() |
Usando la clase MicroMLP.NNValue :
| Nombre | Función |
|---|
| Constructor | nnvalue = MicroMLP.NNValue(minValue, maxValue, value) |
| Propiedad | Ejemplo | Leer/Escribir |
|---|
| Como flotar | nnvalue.AsFloat = 639.513 | obtener / establecer |
| AsInt | nnvalue.AsInt = 12345 | obtener / establecer |
| Como porcentaje | nnvalue.AsPercent = 65 | obtener / establecer |
| ComoByte | nnvalue.AsByte = b'x75' | obtener / establecer |
| comobool | nnvalue.AsBool = True | obtener / establecer |
| Como señal analógica | nnvalue.AsAnalogSignal = 0.39472 | obtener / establecer |
Por JC`zic para HC² ;')
¿Mantenlo simple, estúpido ?
