brain.js
Expose leakyReluAlpha as NeuralNetwork option
Redes neuronales aceleradas de GPU en JavaScript para navegadores y nodos.js
brain.js es una biblioteca acelerada de GPU para redes neuronales escritas en JavaScript.
Esta es una continuación del Harthur/Brain , que ya no se mantiene. Más información
RNNTimeStep , LSTMTimeStep y GRUTimeStepRNN , LSTM y GRUAElikelytoSVG Si puede instalar brain.js con NPM:
npm install brain.js < script src =" //unpkg.com/brain.js " > </ script >Descargue el último Brain.js para el navegador
Brain.js depende de un módulo nativo headless-gl para el soporte de GPU. En la mayoría de los casos, la instalación de brain.js de NPM solo debería funcionar. Sin embargo, si se encuentra con problemas, esto significa que los binarios prebuidados no pueden descargar desde los repositorios de GitHub y es posible que deba construirlo usted mismo.
Asegúrese de que las siguientes dependencias estén instaladas y actualizadas y luego ejecute:
npm rebuildbuild-essential en apt )sudo apt-get install -y build-essential libglew-dev libglu1-mesa-dev libxi-dev pkg-confignpm config set msvs_version 2022 Nota: Esto ya no funciona en versiones modernas de NPM.npm config set python python3 Nota: Esto ya no funciona en versiones modernas de NPM. * Si está utilizando Build Tools 2017 , ejecute npm config set msvs_version 2017 Nota: Esto ya no funciona en versiones modernas de NPM.
Aquí hay un ejemplo que muestra cómo aproximar la función XOR usando brain.js : más información sobre la configuración aquí.
Una introducción divertida y práctica al cerebro.js
// provide optional config object (or undefined). Defaults shown.
const config = {
binaryThresh : 0.5 ,
hiddenLayers : [ 3 ] , // array of ints for the sizes of the hidden layers in the network
activation : 'sigmoid' , // supported activation types: ['sigmoid', 'relu', 'leaky-relu', 'tanh'],
leakyReluAlpha : 0.01 , // supported for activation type 'leaky-relu'
} ;
// create a simple feed-forward neural network with backpropagation
const net = new brain . NeuralNetwork ( config ) ;
net . train ( [
{ input : [ 0 , 0 ] , output : [ 0 ] } ,
{ input : [ 0 , 1 ] , output : [ 1 ] } ,
{ input : [ 1 , 0 ] , output : [ 1 ] } ,
{ input : [ 1 , 1 ] , output : [ 0 ] } ,
] ) ;
const output = net . run ( [ 1 , 0 ] ) ; // [0.987]o más información sobre la configuración aquí.
// provide optional config object, defaults shown.
const config = {
inputSize : 20 ,
inputRange : 20 ,
hiddenLayers : [ 20 , 20 ] ,
outputSize : 20 ,
learningRate : 0.01 ,
decayRate : 0.999 ,
} ;
// create a simple recurrent neural network
const net = new brain . recurrent . RNN ( config ) ;
net . train ( [
{ input : [ 0 , 0 ] , output : [ 0 ] } ,
{ input : [ 0 , 1 ] , output : [ 1 ] } ,
{ input : [ 1 , 0 ] , output : [ 1 ] } ,
{ input : [ 1 , 1 ] , output : [ 0 ] } ,
] ) ;
let output = net . run ( [ 0 , 0 ] ) ; // [0]
output = net . run ( [ 0 , 1 ] ) ; // [1]
output = net . run ( [ 1 , 0 ] ) ; // [1]
output = net . run ( [ 1 , 1 ] ) ; // [0]Sin embargo, no hay razón para usar una red neuronal para descubrir XOR. (-: Entonces, aquí hay un ejemplo más involucrado y realista: demostración: capacitación de una red neuronal para reconocer el contraste de color.
Brain.js Ejemplos Repo
Puede consultar este fantástico screencast, que explica cómo entrenar una red neuronal simple utilizando un conjunto de datos del mundo real: cómo crear una red neuronal en el navegador usando Brain.js.
Use train() para entrenar la red con una variedad de datos de capacitación. La red debe ser entrenada con todos los datos a granel en una llamada para train() . Más patrones de entrenamiento probablemente tardarán más en entrenar, pero generalmente dará como resultado una red mejor para clasificar nuevos patrones.
La capacitación es computacionalmente costosa, por lo que debe intentar capacitar la red fuera de línea (o en un trabajador) y usar las opciones toFunction() o toJSON() para conectar la red previa al entrenamiento a su sitio web.
NeuralNetwork Cada patrón de entrenamiento debe tener una input y una output , los cuales pueden ser una matriz de números de 0 a 1 o un hash de números de 0 a 1 . Para la demostración de contraste de color se ve algo así:
const net = new brain . NeuralNetwork ( ) ;
net . train ( [
{ input : { r : 0.03 , g : 0.7 , b : 0.5 } , output : { black : 1 } } ,
{ input : { r : 0.16 , g : 0.09 , b : 0.2 } , output : { white : 1 } } ,
{ input : { r : 0.5 , g : 0.5 , b : 1.0 } , output : { white : 1 } } ,
] ) ;
const output = net . run ( { r : 1 , g : 0.4 , b : 0 } ) ; // { white: 0.99, black: 0.002 }Aquí hay otra variación del ejemplo anterior. ( Tenga en cuenta que los objetos de entrada no necesitan ser similares).
net . train ( [
{ input : { r : 0.03 , g : 0.7 } , output : { black : 1 } } ,
{ input : { r : 0.16 , b : 0.2 } , output : { white : 1 } } ,
{ input : { r : 0.5 , g : 0.5 , b : 1.0 } , output : { white : 1 } } ,
] ) ;
const output = net . run ( { r : 1 , g : 0.4 , b : 0 } ) ; // { white: 0.81, black: 0.18 } RNNTimeStep , LSTMTimeStep y GRUTimeStepCada patrón de entrenamiento puede:
Ejemplo usando una matriz de números:
const net = new brain . recurrent . LSTMTimeStep ( ) ;
net . train ( [ [ 1 , 2 , 3 ] ] ) ;
const output = net . run ( [ 1 , 2 ] ) ; // 3Ejemplo usando una matriz de matrices de números:
const net = new brain . recurrent . LSTMTimeStep ( {
inputSize : 2 ,
hiddenLayers : [ 10 ] ,
outputSize : 2 ,
} ) ;
net . train ( [
[ 1 , 3 ] ,
[ 2 , 2 ] ,
[ 3 , 1 ] ,
] ) ;
const output = net . run ( [
[ 1 , 3 ] ,
[ 2 , 2 ] ,
] ) ; // [3, 1] RNN , LSTM y GRUCada patrón de entrenamiento puede:
input y una outputPRECAUCIÓN: cuando se usa una matriz de valores, puede usar cualquier valor, sin embargo, los valores se representan en la red neuronal mediante una sola entrada. Entonces, cuanto más distintos valores tienen , mayor será su capa de entrada . Si tiene cientos, miles o millones de valores de puntos flotantes , esta no es la clase adecuada para el trabajo . Además, cuando se desvía de las cuerdas, esto entra en beta
Ejemplo Uso de cadenas directas: hola mundo usando Brainjs
const net = new brain . recurrent . LSTM ( ) ;
net . train ( [ 'I am brainjs, Hello World!' ] ) ;
const output = net . run ( 'I am brainjs' ) ;
alert ( output ) ; const net = new brain . recurrent . LSTM ( ) ;
net . train ( [
'doe, a deer, a female deer' ,
'ray, a drop of golden sun' ,
'me, a name I call myself' ,
] ) ;
const output = net . run ( 'doe' ) ; // ', a deer, a female deer'Ejemplo usando cadenas con entradas y salidas:
const net = new brain . recurrent . LSTM ( ) ;
net . train ( [
{ input : 'I feel great about the world!' , output : 'happy' } ,
{ input : 'The world is a terrible place!' , output : 'sad' } ,
] ) ;
const output = net . run ( 'I feel great about the world!' ) ; // 'happy' AECada patrón de entrenamiento puede:
Entrenamiento de un autoencoder para comprimir los valores de un cálculo de XOR:
const net = new brain . AE (
{
hiddenLayers : [ 5 , 2 , 5 ]
}
) ;
net . train ( [
[ 0 , 0 , 0 ] ,
[ 0 , 1 , 1 ] ,
[ 1 , 0 , 1 ] ,
[ 1 , 1 , 0 ]
] ) ;Codificación/decodificación:
const input = [ 0 , 1 , 1 ] ;
const encoded = net . encode ( input ) ;
const decoded = net . decode ( encoded ) ;Datos ruidosos de Denoise:
const noisyData = [ 0 , 1 , 0 ] ;
const data = net . denoise ( noisyData ) ;Prueba de anomalías en muestras de datos:
const shouldBeFalse = net . includesAnomalies ( [ 0 , 1 , 1 ] ) ;
const shouldBeTrue = net . includesAnomalies ( [ 0 , 1 , 0 ] ) ; train() toma un hash de opciones como segundo argumento:
net . train ( data , {
// Defaults values --> expected validation
iterations : 20000 , // the maximum times to iterate the training data --> number greater than 0
errorThresh : 0.005 , // the acceptable error percentage from training data --> number between 0 and 1
log : false , // true to use console.log, when a function is supplied it is used --> Either true or a function
logPeriod : 10 , // iterations between logging out --> number greater than 0
learningRate : 0.3 , // scales with delta to effect training rate --> number between 0 and 1
momentum : 0.1 , // scales with next layer's change value --> number between 0 and 1
callback : null , // a periodic call back that can be triggered while training --> null or function
callbackPeriod : 10 , // the number of iterations through the training data between callback calls --> number greater than 0
timeout : number , // the max number of milliseconds to train for --> number greater than 0. Default --> Infinity
} ) ; La red dejará de entrenar cada vez que se cumplan uno de los dos criterios: el error de entrenamiento se ha reducido al umbral (predeterminado 0.005 ), o se ha alcanzado el número máximo de iteraciones (predeterminado 20000 ).
Por defecto, la capacitación no le permitirá saber cómo está hasta el final, pero configure log en true para obtener actualizaciones periódicas sobre el error de entrenamiento actual de la red. El error de entrenamiento debería disminuir cada vez. Las actualizaciones se imprimirán en la consola. Si establece log en una función, esta función se llamará con las actualizaciones en lugar de imprimir en la consola. Sin embargo, si desea usar los valores de las actualizaciones en su propia salida, la callback se puede configurar en una función para hacerlo.
La tasa de aprendizaje es un parámetro que influye en la rapidez con que la red entrena. Es un número de 0 a 1 . Si la tasa de aprendizaje es cercana a 0 , llevará más tiempo entrenar. Si la tasa de aprendizaje está más cerca de 1 , entrenará más rápido, pero los resultados de la capacitación pueden estar limitados a un mínimo local y desempeñarse mal en nuevos datos. ( Overecitante ) La tasa de aprendizaje predeterminada es 0.3 .
El impulso es similar a la tasa de aprendizaje, esperando un valor de 0 a 1 también, pero se multiplica contra el valor de cambio del siguiente nivel. El valor predeterminado es 0.1
Cualquiera de estas opciones de capacitación se puede pasar al constructor o pasar al método updateTrainingOptions(opts) y se guardarán en la red y se utilizarán durante el tiempo de entrenamiento. Si guarda su red a JSON, estas opciones de capacitación se guardan y restauran también (excepto la devolución de llamada y el registro, la devolución de llamada se olvidará y se restaurará el registro usando console.log).
Una propiedad booleana llamada invalidTrainOptsShouldThrow se establece en true de forma predeterminada. Si bien la opción es true , si ingresa una opción de entrenamiento que está fuera del rango normal, se lanzará un error con un mensaje sobre la opción anormal. Cuando la opción se establece en false , no se enviará ningún error, pero aún se enviará un mensaje a console.warn con la información relacionada.
trainAsync() toma los mismos argumentos que el tren (datos y opciones). En lugar de devolver el objeto de resultados de la capacitación, devuelve una promesa de que cuando se resuelve devolverá el objeto de resultados de la capacitación. No funciona con:
brain.recurrent.RNNbrain.recurrent.GRUbrain.recurrent.LSTMbrain.recurrent.RNNTimeStepbrain.recurrent.GRUTimeStepbrain.recurrent.LSTMTimeStep const net = new brain . NeuralNetwork ( ) ;
net
. trainAsync ( data , options )
. then ( ( res ) => {
// do something with my trained network
} )
. catch ( handleError ) ;Con varias redes puede entrenar en paralelo como este:
const net = new brain . NeuralNetwork ( ) ;
const net2 = new brain . NeuralNetwork ( ) ;
const p1 = net . trainAsync ( data , options ) ;
const p2 = net2 . trainAsync ( data , options ) ;
Promise . all ( [ p1 , p2 ] )
. then ( ( values ) => {
const res = values [ 0 ] ;
const res2 = values [ 1 ] ;
console . log (
`net trained in ${ res . iterations } and net2 trained in ${ res2 . iterations } `
) ;
// do something super cool with my 2 trained networks
} )
. catch ( handleError ) ;La validación cruzada puede proporcionar una forma de capacitación menos frágil en conjuntos de datos más grandes. La API Brain.js proporciona validación cruzada en este ejemplo:
const crossValidate = new brain . CrossValidate ( ( ) => new brain . NeuralNetwork ( networkOptions ) ) ;
crossValidate . train ( data , trainingOptions , k ) ; //note k (or KFolds) is optional
const json = crossValidate . toJSON ( ) ; // all stats in json as well as neural networks
const net = crossValidate . toNeuralNetwork ( ) ; // get top performing net out of `crossValidate`
// optionally later
const json = crossValidate . toJSON ( ) ;
const net = crossValidate . fromJSON ( json ) ; Use CrossValidate con estas clases:
brain.NeuralNetworkbrain.RNNTimeStepbrain.LSTMTimeStepbrain.GRUTimeStepSe puede encontrar un ejemplo de uso de Cross Validate en Validato Cross-Validato.
train(trainingData) -> Trainingstatus La salida de train() es un hash de información sobre cómo fue el entrenamiento:
{
error : 0.0039139985510105032 , // training error
iterations : 406 // training iterations
}run(input) -> predicciónCompatible con clases:
brain.NeuralNetworkbrain.NeuralNetworkGPU -> Toda la funcionalidad de brain.NeuralNetwork pero se ejecutó en GPU (a través de GPU.js en WebGL2, WebGL1 o Flack a CPU)brain.recurrent.RNNbrain.recurrent.LSTMbrain.recurrent.GRUbrain.recurrent.RNNTimeStepbrain.recurrent.LSTMTimeStepbrain.recurrent.GRUTimeStepEjemplo:
// feed forward
const net = new brain . NeuralNetwork ( ) ;
net . fromJSON ( json ) ;
net . run ( input ) ;
// time step
const net = new brain . LSTMTimeStep ( ) ;
net . fromJSON ( json ) ;
net . run ( input ) ;
// recurrent
const net = new brain . LSTM ( ) ;
net . fromJSON ( json ) ;
net . run ( input ) ;forecast(input, count) -> prediccionesDisponible con las siguientes clases. Emite una matriz de predicciones. Las predicciones son una continuación de las entradas.
brain.recurrent.RNNTimeStepbrain.recurrent.LSTMTimeStepbrain.recurrent.GRUTimeStepEjemplo:
const net = new brain . LSTMTimeStep ( ) ;
net . fromJSON ( json ) ;
net . forecast ( input , 3 ) ;toJSON() -> jsonSerializar la red neuronal a JSON
fromJSON(json)Deserializar la red neuronal de JSON
Si la red no pudo entrenar, el error estará por encima del umbral de error. Esto podría suceder si los datos de entrenamiento son demasiado ruidosos (muy probablemente), la red no tiene suficientes capas o nodos ocultos para manejar la complejidad de los datos, o no ha sido entrenada para suficientes iteraciones.
Si el error de entrenamiento sigue siendo algo enorme como 0.4 después de 20000 iteraciones, es una buena señal de que la red no puede dar sentido a los datos dados.
Se puede establecer la instancia de la propiedad de la red maxPredictionLength (predeterminada 100) para ajustar la salida de la red;
Ejemplo:
const net = new brain . recurrent . LSTM ( ) ;
// later in code, after training on a few novels, write me a new one!
net . maxPredictionLength = 1000000000 ; // Be careful!
net . run ( 'Once upon a time' ) ; Serializar o cargar en el estado de una red capacitada con JSON:
const json = net . toJSON ( ) ;
net . fromJSON ( json ) ; También puede obtener una función independiente personalizada de una red capacitada que actúa como run() ::
const run = net . toFunction ( ) ;
const output = run ( { r : 1 , g : 0.4 , b : 0 } ) ;
console . log ( run . toString ( ) ) ; // copy and paste! no need to import brain.js NeuralNetwork() toma un hash de opciones:
const net = new brain . NeuralNetwork ( {
activation : 'sigmoid' , // activation function
hiddenLayers : [ 4 ] ,
learningRate : 0.6 , // global learning rate, useful when training using streams
} ) ;Este parámetro le permite especificar qué función de activación debe usar su red neuronal. Actualmente hay cuatro funciones de activación compatibles, Sigmoid es el valor predeterminado:
Aquí hay una mesa (¡gracias, wikipedia!) Resumiendo una gran cantidad de funciones de activación - función de activación
Puede usar esto para especificar el número de capas ocultas en la red y el tamaño de cada capa. Por ejemplo, si desea dos capas ocultas: la primera con 3 nodos y el segundo con 4 nodos, daría:
hiddenLayers: [ 3 , 4 ] ; Por defecto, brain.js usa una capa oculta con el tamaño proporcional al tamaño de la matriz de entrada.
Use https://www.npmjs.com/package/train-stream para transmitir datos a una red neural
likely const likely = require ( 'brain/likely' ) ;
const key = likely ( input , net ) ;Ejemplo probable Ver: detección de letras simples
toSVG < script src = "../../src/utilities/svg.js" > </ script >Representa la topología de la red de una red FeedForward
document . getElementById ( 'result' ) . innerHTML = brain . utilities . toSVG (
network ,
options
) ;Ejemplo de TOSVG Ver: Representación de red
La interfaz de usuario utilizada: 
brain.NeuralNetwork - Feedforward Network Neural con backpropagationbrain.NeuralNetworkGPU - red neuronal de FeedForward con backpropagation, versión de GPUbrain.AE - Autoencoder o "AE" con backpropogation y soporte de GPUbrain.recurrent.RNNTimeStep - Tiempo Paso Red neural recurrente o "RNN"brain.recurrent.LSTMTimeStep - TIEMPO PASO A LARGO A LA RED NECOMA DE MEMORIA A CORTO TENTRO O "LSTM"brain.recurrent.GRUTimeStep - Tiempo Paso cerrado Unidad recurrente o "Gru"brain.recurrent.RNN - Red neuronal recurrente o "RNN"brain.recurrent.LSTM - Red neural de memoria a corto plazo a corto plazo o "LSTM"brain.recurrent.GRU - Unidad recurrente cerrada o "Gru"brain.FeedForward : red neuronal de Feedforward altamente personalizable con backpropagationbrain.Recurrent : red neuronal recurrente altamente personalizable con backpropagationDiferentes redes neuronales hacen bien cosas diferentes. Por ejemplo:
Si usted es un desarrollador o si solo le importa cómo debe verse la API ML, participe y únase a la comunidad W3C y comparta sus opiniones o simplemente apoya las opiniones con las que le gustan o están de acuerdo.
Brain.js es una biblioteca de aprendizaje automático de código abierto ampliamente adoptada en el mundo de JavaScript. Hay varias razones para ello, pero lo más notable es la simplicidad de uso sin sacrificar el rendimiento . Nos gustaría mantenerlo también simple de aprender, fácil de usar y rendimiento cuando se trata de estándar W3C. Creemos que la API Brain.JS actual está bastante cerca de lo que podríamos esperar para convertirse en un estándar. Y dado que el apoyo no requiere mucho esfuerzo y aún puede hacer una gran diferencia, siéntase libre de unirse a W3C Community Group y apoyarnos con Brain.js como API.
Involucrarse en el proceso de estandarización continua de aprendizaje automático W3C aquí. También puede unirse a nuestra discusión abierta sobre la estandarización aquí.
Si tiene un problema, un error o una característica que cree que beneficiaría a su proyecto, háganoslo saber y haremos todo lo posible.
Cree problemas aquí y siga la plantilla.
La fuente para brain.js.org está disponible en Brain.js.org Repository. Construido usando impresionante vue.js & bulma . Las contribuciones siempre son bienvenidas.
Este proyecto existe gracias a todas las personas que contribuyen. [Contribuir].
¡Gracias a todos nuestros patrocinadores! [Conviértete en un patrocinador]
Apoye este proyecto al convertirse en patrocinador. Su logotipo aparecerá aquí con un enlace a su sitio web. [Convertirse en patrocinador]
