brain.js
Expose leakyReluAlpha as NeuralNetwork option
GPU a accéléré les réseaux de neurones en JavaScript pour les navigateurs et Node.js
brain.js est une bibliothèque accélérée GPU pour les réseaux de neurones écrits en JavaScript.
Il s'agit d'une continuation du Harthur / Brain , qui n'est plus maintenue. Plus d'informations
RNNTimeStep , LSTMTimeStep et GRUTimeStepRNN , LSTM et GRUAElikelytoSVG Si vous pouvez installer brain.js avec NPM:
npm install brain.js < script src =" //unpkg.com/brain.js " > </ script >Téléchargez le dernier cerveau.js pour le navigateur
Brain.js dépend d'un module natif headless-gl pour le support GPU. Dans la plupart des cas, l'installation brain.js de NPM devrait simplement fonctionner. Cependant, si vous rencontrez des problèmes, cela signifie que les binaires prédéfinis ne sont pas en mesure de télécharger à partir de référentiels GitHub et vous devrez peut-être le construire vous-même.
Veuillez vous assurer que les dépendances suivantes sont installées et à jour, puis exécutez:
npm rebuildbuild-essential sur apt )sudo apt-get install -y build-essential libglew-dev libglu1-mesa-dev libxi-dev pkg-confignpm config set msvs_version 2022 Remarque: Cela ne fonctionne plus dans les versions modernes de NPM.npm config set python python3 Remarque: Cela ne fonctionne plus dans les versions modernes de NPM. * Si vous utilisez Build Tools 2017 , exécutez npm config set msvs_version 2017 Remarque: Cela ne fonctionne plus dans les versions modernes de NPM.
Voici un exemple montrant comment approximer la fonction XOR à l'aide de brain.js : plus d'informations sur la configuration ici.
Une introduction amusante et pratique à Brain.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]ou plus d'informations sur la configuration ici.
// 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]Cependant, il n'y a aucune raison d'utiliser un réseau de neurones pour déterminer XOR. (-:: Voici donc un exemple plus impliqué et réaliste: Demo: former un réseau neuronal pour reconnaître le contraste des couleurs.
Brain.js Exemples Repo
Vous pouvez consulter ce fantastique screencast, qui explique comment former un réseau neuronal simple à l'aide d'un ensemble de données du monde réel: comment créer un réseau neuronal dans le navigateur à l'aide de Brain.js.
Utilisez train() pour former le réseau avec un éventail de données de formation. Le réseau doit être formé avec toutes les données en vrac en un seul appel à train() . D'autres modèles de formation prendront probablement plus de temps à s'entraîner, mais entraîneront généralement un réseau mieux pour classer les nouveaux modèles.
La formation est coûteuse en calcul, vous devez donc essayer de former le réseau hors ligne (ou sur un travailleur) et utiliser les options toFunction() ou toJSON() pour brancher le réseau pré-formé sur votre site Web.
NeuralNetwork Chaque modèle de formation doit avoir une input et une output , qui peuvent être soit un tableau de nombres de 0 à 1 , soit un hachage de nombres de 0 à 1 . Pour la démo de contraste des couleurs, cela ressemble à ceci:
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 }Voici une autre variation de l'exemple ci-dessus. ( Notez que les objets d'entrée n'ont pas besoin d'être similaires.)
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 et GRUTimeStepChaque modèle de formation peut soit:
Exemple utilisant un tableau de nombres:
const net = new brain . recurrent . LSTMTimeStep ( ) ;
net . train ( [ [ 1 , 2 , 3 ] ] ) ;
const output = net . run ( [ 1 , 2 ] ) ; // 3Exemple utilisant un tableau de tableaux de nombres:
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 et GRUChaque modèle de formation peut soit:
input et une outputATTENTION: Lorsque vous utilisez un tableau de valeurs, vous pouvez utiliser n'importe quelle valeur, cependant, les valeurs sont représentées dans le réseau neuronal par une seule entrée. Donc, les valeurs les plus distinctes ont plus votre couche d'entrée . Si vous en avez une centaine, des milliers ou des millions de valeurs de points flottants , ce n'est pas la bonne classe pour le travail . De plus, lorsqu'il s'écarte des cordes, cela entre en version bêta
Exemple utilisant des chaînes directes: bonjour le monde en utilisant 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'Exemple utilisant des chaînes avec des entrées et des sorties:
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' AEChaque modèle de formation peut soit:
Formation d'un autoencoder pour comprimer les valeurs d'un calcul XOR:
const net = new brain . AE (
{
hiddenLayers : [ 5 , 2 , 5 ]
}
) ;
net . train ( [
[ 0 , 0 , 0 ] ,
[ 0 , 1 , 1 ] ,
[ 1 , 0 , 1 ] ,
[ 1 , 1 , 0 ]
] ) ;Encodage / décodage:
const input = [ 0 , 1 , 1 ] ;
const encoded = net . encode ( input ) ;
const decoded = net . decode ( encoded ) ;Données bruyantes Denoise:
const noisyData = [ 0 , 1 , 0 ] ;
const data = net . denoise ( noisyData ) ;Tester des anomalies dans des échantillons de données:
const shouldBeFalse = net . includesAnomalies ( [ 0 , 1 , 1 ] ) ;
const shouldBeTrue = net . includesAnomalies ( [ 0 , 1 , 0 ] ) ; train() prend un hachage d'options comme deuxième argument:
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
} ) ; Le réseau arrêtera la formation chaque fois que l'un des deux critères est rempli: l'erreur de formation est allée en dessous du seuil (par défaut 0.005 ), ou le nombre maximum d'itérations (par défaut 20000 ) a été atteint.
Par défaut, la formation ne vous permettra pas de savoir comment cela se passe avant la fin, mais définissez log sur true pour obtenir des mises à jour périodiques sur l'erreur de formation actuelle du réseau. L'erreur de formation devrait diminuer à chaque fois. Les mises à jour seront imprimées sur la console. Si vous définissez log sur une fonction, cette fonction sera appelée avec les mises à jour au lieu d'imprimer sur la console. Cependant, si vous souhaitez utiliser les valeurs des mises à jour dans votre propre sortie, le callback peut être défini sur une fonction pour le faire à la place.
Le taux d'apprentissage est un paramètre qui influence la rapidité avec laquelle le réseau s'entraîne. C'est un nombre de 0 à 1 . Si le taux d'apprentissage est proche de 0 , il faudra plus de temps pour s'entraîner. Si le taux d'apprentissage est plus proche de 1 , il s'entraînera plus rapidement, mais que les résultats de formation peuvent être limités à un minimum local et fonctionner mal sur de nouvelles données. ( Sur-ajustement ) Le taux d'apprentissage par défaut est 0.3 .
L'élan est similaire au taux d'apprentissage, s'attendant également à une valeur de 0 à 1 , mais il est multiplié par rapport à la valeur de changement du niveau suivant. La valeur par défaut est 0.1
N'importe laquelle de ces options de formation peut être transmise dans le constructeur ou transmise dans la méthode updateTrainingOptions(opts) et elles seront enregistrées sur le réseau et utilisées pendant le temps de formation. Si vous enregistrez votre réseau sur JSON, ces options de formation sont également enregistrées et restaurées (à l'exception du rappel et du journal, le rappel sera oublié et le journal sera restauré à l'aide de Console.log).
Une propriété booléenne appelée invalidTrainOptsShouldThrow est définie sur true par défaut. Bien que l'option soit true , si vous entrez une option de formation qui est en dehors de la plage normale, une erreur sera lancée avec un message sur l'option anormale. Lorsque l'option est définie sur false , aucune erreur ne sera envoyée, mais un message sera toujours envoyé à console.warn avec les informations connexes.
trainAsync() prend les mêmes arguments que Train (données et options). Au lieu de retourner l'objet de résultats de la formation, il renvoie une promesse que, une fois résolu, renvoie l'objet de résultats de formation. Ne fonctionne pas avec:
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 ) ;Avec plusieurs réseaux, vous pouvez vous entraîner en parallèle comme ceci:
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 validation croisée peut fournir un moyen moins fragile de s'entraîner sur des ensembles de données plus importants. L'API Brain.js fournit une validation croisée dans cet exemple:
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 ) ; Utilisez CrossValidate avec ces classes:
brain.NeuralNetworkbrain.RNNTimeStepbrain.LSTMTimeStepbrain.GRUTimeStepUn exemple d'utilisation de validate croisée peut être trouvé dans la validate croisée.ts
train(trainingData) -> Trainingstatus La sortie de train() est un hachage d'informations sur la façon dont la formation s'est déroulée:
{
error : 0.0039139985510105032 , // training error
iterations : 406 // training iterations
}run(input) -> PrédictionPrise en charge des cours:
brain.NeuralNetworkbrain.NeuralNetworkGPU -> Toutes les fonctionnalités de brain.NeuralNetwork mais, ont fonctionné sur GPU (via GPU.JS dans WebGL2, WebGL1 ou Fallback sur CPU)brain.recurrent.RNNbrain.recurrent.LSTMbrain.recurrent.GRUbrain.recurrent.RNNTimeStepbrain.recurrent.LSTMTimeStepbrain.recurrent.GRUTimeStepExemple:
// 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) -> PrédictionsDisponible avec les cours suivants. Sorte un tableau de prédictions. Les prédictions étant une continuation des intrants.
brain.recurrent.RNNTimeStepbrain.recurrent.LSTMTimeStepbrain.recurrent.GRUTimeStepExemple:
const net = new brain . LSTMTimeStep ( ) ;
net . fromJSON ( json ) ;
net . forecast ( input , 3 ) ;toJSON() -> jsonSérialisez le réseau de neurones à JSON
fromJSON(json)Désérialiser le réseau de neurones de JSON
Si le réseau n'a pas réussi à s'entraîner, l'erreur sera supérieure au seuil d'erreur. Cela pourrait se produire si les données de formation sont trop bruyantes (très probablement), le réseau n'a pas suffisamment de couches ou de nœuds cachés pour gérer la complexité des données, ou il n'a pas été formé pour suffisamment d'itérations.
Si l'erreur de formation est encore quelque chose d'énorme comme 0.4 après 20000 itérations, c'est un bon signe que le réseau ne peut pas donner un sens aux données données.
L'instance de la propriété du net maxPredictionLength (par défaut 100) peut être définie pour ajuster la sortie du net;
Exemple:
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' ) ; Sérialisez ou chargez dans l'état d'un réseau formé avec JSON:
const json = net . toJSON ( ) ;
net . fromJSON ( json ) ; Vous pouvez également obtenir une fonction autonome personnalisée à partir d'un réseau formé qui agit comme 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() prend un hachage d'options:
const net = new brain . NeuralNetwork ( {
activation : 'sigmoid' , // activation function
hiddenLayers : [ 4 ] ,
learningRate : 0.6 , // global learning rate, useful when training using streams
} ) ;Ce paramètre vous permet de spécifier la fonction d'activation que votre réseau neuronal doit utiliser. Il existe actuellement quatre fonctions d'activation prises en charge, Sigmoïd étant la valeur par défaut:
Voici une table (merci, Wikipedia!) Résumant une pléthore de fonctions d'activation - fonction d'activation
Vous pouvez l'utiliser pour spécifier le nombre de couches cachées dans le réseau et la taille de chaque couche. Par exemple, si vous voulez deux couches cachées - la première avec 3 nœuds et la seconde avec 4 nœuds, vous donneriez:
hiddenLayers: [ 3 , 4 ] ; Par défaut, brain.js utilise une couche cachée avec une taille proportionnée à la taille du tableau d'entrée.
Utilisez https://www.npmjs.com/package/train-tream pour diffuser des données sur un neuralnetwork
likely const likely = require ( 'brain/likely' ) ;
const key = likely ( input , net ) ;Exemple probable Voir: détection de lettres simple
toSVG < script src = "../../src/utilities/svg.js" > </ script >Rend la topologie du réseau d'un réseau de restauration
document . getElementById ( 'result' ) . innerHTML = brain . utilities . toSVG (
network ,
options
) ;Exemple TOSVG Voir: rendu de réseau
L'interface utilisateur utilisée: 
brain.NeuralNetwork - FeedForward Networal Networal with Backpropagationbrain.NeuralNetworkGPU - FeedForward Network avec rétro-compatir, version GPUbrain.AE - Autoencoder ou "AE" avec rétropropogation et support GPUbrain.recurrent.RNNTimeStep - Réseau neuronal récurrent de pas de temps ou "RNN"brain.recurrent.LSTMTimeStep - temps de temps à court terme de mémoire neuronale à court terme ou "LSTM"brain.recurrent.GRUTimeStep - unité récurrente fermée de temps ou «GRU»brain.recurrent.RNN - Réseau de neurones récurrent ou "RNN"brain.recurrent.LSTM - Long terme Réseau neuronal de mémoire à court terme ou "LSTM"brain.recurrent.GRU - unité récurrente fermée ou "GRU"brain.FeedForward - Réseau de neurones à actionbrain.Recurrent - Réseau de neurones récurrent hautement personnalisable avec rétro-épropagationDifférents réseaux neuronaux font bien des choses. Par exemple:
Si vous êtes un développeur ou si vous vous souciez simplement de l'apparence de l'API ML, veuillez participer et rejoindre la communauté W3C et partager vos opinions ou simplement soutenir les opinions que vous aimez ou acceptez-vous.
Brain.js est une bibliothèque d'apprentissage automatique open source largement adoptée dans le monde JavaScript. Il y a plusieurs raisons à cela, mais le plus notable est la simplicité d'utilisation sans sacrifier les performances . Nous aimerions le garder simple à apprendre, simple à utiliser et à performant en ce qui concerne la norme W3C. Nous pensons que l'API Current Brain.js est assez proche de ce que nous pouvions nous attendre à devenir une norme. Et comme le soutien ne nécessite pas beaucoup d'efforts et peut encore faire une énorme différence, n'hésitez pas à rejoindre le groupe communautaire W3C et à nous soutenir avec Brain.js comme l'API.
Impliquez-vous dans le processus de normalisation en cours W3C d'apprentissage automatique ici. Vous pouvez également rejoindre notre discussion ouverte sur la normalisation ici.
Si vous avez un problème, un bug ou une fonctionnalité qui, selon vous, profiterait à votre projet, faites-le nous savoir et nous ferons de notre mieux.
Créez des problèmes ici et suivez le modèle.
La source de brain.js.org est disponible dans le référentiel Brain.js.org. Construit en utilisant Awesome vue.js & bulma . Les contributions sont toujours les bienvenues.
Ce projet existe grâce à toutes les personnes qui contribuent. [Contribuer].
Merci à tous nos bailleurs de fonds! [Devenez un bailleur de fonds]
Soutenez ce projet en devenant un sponsor. Votre logo apparaîtra ici avec un lien vers votre site Web. [Devenir sponsor]
