brain.js
Expose leakyReluAlpha as NeuralNetwork option
GPU acelerou redes neurais em JavaScript para navegadores e node.js
brain.js é uma biblioteca acelerada da GPU para redes neurais escritas em JavaScript.
Esta é uma continuação do Harthur/Brain , que não é mais mantido. Mais informações
RNNTimeStep , LSTMTimeStep e GRUTimeStepRNN , LSTM e GRUAElikelytoSVG Se você pode instalar brain.js com o NPM:
npm install brain.js < script src =" //unpkg.com/brain.js " > </ script >Baixe o mais recente cérebro.js para navegador
Brain.js depende de um módulo nativo headless-gl para suporte à GPU. Na maioria dos casos, a instalação brain.js do NPM deve funcionar. No entanto, se você tiver problemas, isso significa que os binários pré -construídos não poderão fazer o download dos repositórios do GitHub e você pode precisar construí -lo sozinho.
Verifique se as seguintes dependências estão instaladas e atualizadas e executadas:
npm rebuildbuild-essential no apt )sudo apt-get install -y build-essential libglew-dev libglu1-mesa-dev libxi-dev pkg-confignpm config set msvs_version 2022 Nota: Isso não funciona mais nas versões modernas do NPM.npm config set python python3 Nota: Isso não funciona mais nas versões modernas do NPM. * Se você estiver usando Build Tools 2017 , execute npm config set msvs_version 2017 NOTA: Isso não funciona mais nas versões modernas do NPM.
Aqui está um exemplo mostrando como se aproximar da função XOR usando brain.js : mais informações sobre o Config aqui.
Uma introdução divertida e prática ao 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 mais informações sobre a configuração aqui.
// 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]No entanto, não há razão para usar uma rede neural para descobrir o XOR. (-: Então, aqui está um exemplo mais envolvido e realista: Demo: treinamento de uma rede neural para reconhecer o contraste de cores.
Brain.JS Exemplos Repo
Você pode conferir este screencast fantástico, que explica como treinar uma rede neural simples usando um conjunto de dados do mundo real: como criar uma rede neural no navegador usando o Brain.js.
Use train() para treinar a rede com uma variedade de dados de treinamento. A rede deve ser treinada com todos os dados a granel em uma chamada para train() . Mais padrões de treinamento provavelmente levarão mais tempo para treinar, mas geralmente resultam em uma rede melhor na classificação de novos padrões.
O treinamento é computacionalmente caro, então você deve tentar treinar a rede offline (ou em um trabalhador) e usar as opções toFunction() ou toJSON() para conectar a rede pré-treinada ao seu site.
NeuralNetwork Cada padrão de treinamento deve ter uma input e uma output , os quais podem ser uma matriz de números de 0 a 1 ou um hash de números de 0 a 1 . Para a demonstração de contraste de cores, parece algo assim:
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 }Aqui está outra variação do exemplo acima. ( Observe que os objetos de entrada não precisam ser semelhantes.)
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 e GRUTimeStepCada padrão de treinamento pode também:
Exemplo usando uma variedade de números:
const net = new brain . recurrent . LSTMTimeStep ( ) ;
net . train ( [ [ 1 , 2 , 3 ] ] ) ;
const output = net . run ( [ 1 , 2 ] ) ; // 3Exemplo usando uma matriz de matrizes 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 e GRUCada padrão de treinamento pode também:
input e uma outputCUIDADO: Ao usar uma matriz de valores, você pode usar qualquer valor; no entanto, os valores são representados na rede neural por uma única entrada. Portanto, os valores mais distintos têm a maior camada de entrada . Se você tiver centenas, milhares ou milhões de valores de pontos flutuantes , essa não é a classe certa para o trabalho . Além disso, ao se desviar de Strings, isso entra em beta
Exemplo usando strings diretos: Olá, 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'Exemplo usando strings com entradas e saídas:
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 padrão de treinamento pode também:
Treinando um autoencoder para comprimir os valores de um cálculo XOR:
const net = new brain . AE (
{
hiddenLayers : [ 5 , 2 , 5 ]
}
) ;
net . train ( [
[ 0 , 0 , 0 ] ,
[ 0 , 1 , 1 ] ,
[ 1 , 0 , 1 ] ,
[ 1 , 1 , 0 ]
] ) ;Codificação/decodificação:
const input = [ 0 , 1 , 1 ] ;
const encoded = net . encode ( input ) ;
const decoded = net . decode ( encoded ) ;Dados Denoise Noisy Data:
const noisyData = [ 0 , 1 , 0 ] ;
const data = net . denoise ( noisyData ) ;Teste de anomalias em amostras de dados:
const shouldBeFalse = net . includesAnomalies ( [ 0 , 1 , 1 ] ) ;
const shouldBeTrue = net . includesAnomalies ( [ 0 , 1 , 0 ] ) ; train() toma um hash de opções como seu 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
} ) ; A rede interromperá o treinamento sempre que um dos dois critérios for atendido: o erro de treinamento foi abaixo do limite (padrão 0.005 ) ou o número máximo de iterações (padrão 20000 ) foi atingido.
Por padrão, o treinamento não informará como está indo até o final, mas defina log como true para obter atualizações periódicas sobre o erro atual de treinamento da rede. O erro de treinamento deve diminuir sempre. As atualizações serão impressas no console. Se você definir log como uma função, essa função será chamada com as atualizações em vez de imprimir no console. No entanto, se você deseja usar os valores das atualizações em sua própria saída, o callback poderá ser definido como uma função para fazê -lo.
A taxa de aprendizado é um parâmetro que influencia a rapidez com que a rede treina. É um número de 0 a 1 . Se a taxa de aprendizado estiver próxima de 0 , levará mais tempo para treinar. Se a taxa de aprendizado estiver mais próxima de 1 , ela treinará mais rápido, mas os resultados do treinamento podem ser restringidos ao mínimo local e ter um desempenho ruim em novos dados. ( Excesso de ajuste ) A taxa de aprendizado padrão é 0.3 .
O momento é semelhante à taxa de aprendizado, esperando um valor de 0 a 1 também, mas é multiplicado com o valor de mudança do próximo nível. O valor padrão é 0.1
Qualquer uma dessas opções de treinamento pode ser transmitida para o construtor ou transmitida para o método updateTrainingOptions(opts) e elas serão salvas na rede e usadas durante o tempo de treinamento. Se você salvar sua rede no JSON, essas opções de treinamento também serão salvas e restauradas (exceto o retorno de chamada e o log, o retorno de chamada será esquecido e o log será restaurado usando o console.log).
Uma propriedade booleana chamada invalidTrainOptsShouldThrow é definida como true por padrão. Embora a opção seja true , se você inserir uma opção de treinamento fora do intervalo normal, um erro será lançado com uma mensagem sobre a opção anormal. Quando a opção for definida como false , nenhum erro será enviado, mas uma mensagem ainda será enviada para console.warn com as informações relacionadas.
trainAsync() leva os mesmos argumentos que o trem (dados e opções). Em vez de retornar o objeto de resultados do treinamento, ele retorna uma promessa de que, quando resolvido, retornará o objeto de resultados do treinamento. Não funciona com:
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 ) ;Com várias redes, você pode treinar em paralelo assim:
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 ) ;A validação cruzada pode fornecer uma maneira menos frágil de treinamento em conjuntos de dados maiores. A API Brain.js fornece validação cruzada neste exemplo:
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 com estas classes:
brain.NeuralNetworkbrain.RNNTimeStepbrain.LSTMTimeStepbrain.GRUTimeStepUm exemplo de uso do Cross Validate pode ser encontrado em valides cruzados.ts
train(trainingData) -> TreiningStatus A saída de train() é um hash de informações sobre como foi o treinamento:
{
error : 0.0039139985510105032 , // training error
iterations : 406 // training iterations
}run(input) -> PrevisãoSuportado nas aulas:
brain.NeuralNetworkbrain.NeuralNetworkGPU -> Toda a funcionalidade do brain.NeuralNetwork , mas foi executada na GPU (via GPU.js em Webgl2, Webgl1 ou Fallback to CPU)brain.recurrent.RNNbrain.recurrent.LSTMbrain.recurrent.GRUbrain.recurrent.RNNTimeStepbrain.recurrent.LSTMTimeStepbrain.recurrent.GRUTimeStepExemplo:
// 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) -> previsõesDisponível com as seguintes classes. Produz uma matriz de previsões. Previsões sendo uma continuação das entradas.
brain.recurrent.RNNTimeStepbrain.recurrent.LSTMTimeStepbrain.recurrent.GRUTimeStepExemplo:
const net = new brain . LSTMTimeStep ( ) ;
net . fromJSON ( json ) ;
net . forecast ( input , 3 ) ;toJSON() -> jsonSerialize a rede neural para JSON
fromJSON(json)Desserialize Neural Network da JSON
Se a rede falhar, o erro estará acima do limite de erro. Isso pode acontecer se os dados de treinamento forem muito barulhentos (provavelmente), a rede não possui camadas ou nós ocultos suficientes para lidar com a complexidade dos dados, ou não foi treinado para iterações suficientes.
Se o erro de treinamento ainda for algo enorme como 0.4 após 20000 iterações, é um bom sinal de que a rede não pode entender os dados fornecidos.
A instância da propriedade maxPredictionLength da rede (padrão 100) pode ser configurada para ajustar a saída da rede;
Exemplo:
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 ou carregar no estado de uma rede treinada com o JSON:
const json = net . toJSON ( ) ;
net . fromJSON ( json ) ; Você também pode obter uma função independente personalizada de uma rede treinada que atua 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() leva um hash de opções:
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 permite especificar qual função de ativação sua rede neural deve usar. Atualmente, existem quatro funções de ativação suportadas, sendo o sigmoid o padrão:
Aqui está uma tabela (obrigado, Wikipedia!) Resumindo uma infinidade de funções de ativação - função de ativação
Você pode usar isso para especificar o número de camadas ocultas na rede e o tamanho de cada camada. Por exemplo, se você quiser duas camadas ocultas - a primeira com 3 nós e o segundo com 4 nós, você daria:
hiddenLayers: [ 3 , 4 ] ; Por padrão, brain.js usa uma camada oculta com tamanho proporcional ao tamanho da matriz de entrada.
Use https://www.npmjs.com/package/Train-Stream para transmitir dados para um neuralNetwork
likely const likely = require ( 'brain/likely' ) ;
const key = likely ( input , net ) ;Exemplo provável, veja: detecção de cartas simples
toSVG < script src = "../../src/utilities/svg.js" > </ script >Renderiza a topologia de rede de uma rede de feedforward
document . getElementById ( 'result' ) . innerHTML = brain . utilities . toSVG (
network ,
options
) ;Exemplo de TOSVG Veja: renderização de rede
A interface do usuário usada:
brain.NeuralNetwork - Rede neural de feedforward com retropropagaçãobrain.NeuralNetworkGPU - Rede neural de feedforward com retropropagação, versão da GPUbrain.AE - AutoEncoder ou "AE" com backpropogatório e suporte à GPUbrain.recurrent.RNNTimeStep - Etapa de tempo Rede neural recorrente ou "RNN"brain.recurrent.LSTMTimeStep - Tempo Etapa de memória neural de curto prazo de longo prazo ou "LSTM"brain.recurrent.GRUTimeStep - Etapa do tempo fechado unidade recorrente ou "Gru"brain.recurrent.RNN - Rede neural recorrente ou "RNN"brain.recurrent.LSTM - Rede neural de memória de curto prazo de longo prazo ou "LSTM"brain.recurrent.GRU - Unidade recorrente fechada ou "Gru"brain.FeedForward - Rede neural altamente personalizável com retropropagaçãobrain.Recurrent - Rede neural recorrente altamente personalizável com retropropagaçãoDiferentes redes neurais fazem bem coisas diferentes. Por exemplo:
Se você é um desenvolvedor ou se você se preocupa apenas com a aparência da API da ML - faça uma parte e participe da comunidade W3C e compartilhe suas opiniões ou simplesmente apoie as opiniões com a qual gosta ou concorda.
Brain.js é uma biblioteca de aprendizado de máquina de código aberto amplamente adotado no mundo JavaScript. Existem várias razões para isso, mas o mais notável é a simplicidade de uso, sem sacrificar o desempenho . Gostaríamos de mantê -lo também simples de aprender, simples de usar e performance quando se trata do padrão W3C. Pensamos que a API atual do cérebro.js está bem próxima do que poderíamos esperar para se tornar um padrão. E como apoiar não requer muito esforço e ainda pode fazer uma enorme diferença para se juntar ao Grupo Comunitário W3C e nos apoiar com o Brain.js como a API.
Envolva -se no processo de padronização contínuo do aprendizado de máquina W3C aqui. Você também pode participar de nossa discussão aberta sobre padronização aqui.
Se você tiver um problema, um bug ou um recurso que você acha que beneficiaria seu projeto, informe -nos e faremos o nosso melhor.
Crie problemas aqui e siga o modelo.
Fonte do brain.js.org está disponível no Repositório Brain.js.org. Construído usando o Awesome vue.js & bulma . As contribuições são sempre bem -vindas.
Este projeto existe graças a todas as pessoas que contribuem. [Contribuir].
Obrigado a todos os nossos apoiadores! [Torne -se um patrocinador]
Apoie este projeto, tornando -se um patrocinador. Seu logotipo aparecerá aqui com um link para o seu site. [Torne -se um patrocinador]
