Brain.js
Brain.js je relativno nova biblioteka za strojno učenje koja je razvijena u JavaScriptu. Ova biblioteka omogućuje programerima da koriste neuronske mreže, koje su ključni koncept u području strojnog učenja, bez potrebe za dubljim poznavanjem matematike i algoritama koji stoje iza njih. Ovo omogućuje programerima koji su upoznati sa JavaScriptom da lako implementiraju algoritme strojnog učenja u svojim projektima.
Brain.js koristi neuronske mreže koje su inspirirane načinom na koji funkcionira ljudski mozak. Neuronska mreža se sastoji od velikog broja jedinica koje se nazivaju neuroni. Svaki neuron prima ulazne podatke, obrađuje ih i zatim šalje izlazne podatke sljedećem neuronu u mreži. Kroz ovaj proces neuronske mreže se "uče" kako da prepoznaju obrasce u podacima i donose odluke na temelju tih uzoraka.
Brain.js nudi različite tipove neuronskih mreža koje se mogu koristiti za rješavanje različitih problema. Na primjer, neuronska mreža s petljanjem unatrag (eng. recurrent neural network) koristi se za obradu sekvencijalnih podataka, poput niza znakova ili riječi u tekstu. Konvolucijska neuronska mreža (eng. convolutional neural network) koristi se za obradu slika.
Brain.js se može koristiti za rješavanje različitih problema, poput klasifikacije, predviđanja i prepoznavanja obrazaca. Primjeri primjene uključuju prepoznavanje rukom pisanih slova, klasifikaciju slika, preporuke proizvoda i analizu sentimenta u tekstu.
Brain.js je open-source biblioteka koja je dostupna na GitHubu, a dokumentacija je dostupna na web stranici biblioteke. Biblioteka je lako dostupna za uporabu, čak i za programere koji nemaju puno iskustva s neuronskim mrežama ili strojnim učenjem uopće.
Evo jednostavnog primjera korištenja Brain.js za treniranje neuronske mreže za klasifikaciju brojeva od 0 do 9. U ovom primjeru, koristit ćemo neuronsku mrežu s tri sloja.
const brain = require('brain.js');
// Definirajte skup podataka za treniranje
const trainingData = [
{ input: [0, 0, 0], output: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1] }, // broj 0
{ input: [1, 0, 0], output: [0, 1, 0, 0, 0, 0, 0, 0, 0, 0] }, // broj 1
{ input: [0, 1, 0], output: [0, 0, 1, 0, 0, 0, 0, 0, 0, 0] }, // broj 2
{ input: [0, 0, 1], output: [0, 0, 0, 1, 0, 0, 0, 0, 0, 0] }, // broj 3
{ input: [1, 1, 0], output: [0, 0, 0, 0, 1, 0, 0, 0, 0, 0] }, // broj 4
{ input: [0, 1, 1], output: [0, 0, 0, 0, 0, 1, 0, 0, 0, 0] }, // broj 5
{ input: [1, 1, 1], output: [0, 0, 0, 0, 0, 0, 1, 0, 0, 0] }, // broj 6
{ input: [1, 0, 1], output: [0, 0, 0, 0, 0, 0, 0, 1, 0, 0] }, // broj 7
{ input: [0, 1, 1], output: [0, 0, 0, 0, 0, 0, 0, 0, 1, 0] }, // broj 8
{ input: [1, 1, 0], output: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1] } // broj 9
];
// Izgradite neuronsku mrežu
const net = new brain.NeuralNetwork({
hiddenLayers: [3], // tri skrivena sloja
});
// Trenirajte neuronsku mrežu
net.train(trainingData);
// Testirajte neuronsku mrežu s novim podacima
const output = net.run([1, 0, 0]); // očekivani izlaz je [0, 1, 0, 0, 0, 0, 0, 0, 0, 0], što predstavlja broj 1
console.log(output);
Ovaj primjer uči neuronsku mrežu kako klasificirati brojeve od 0 do 9. Skup podataka za treniranje sadrži 10 primjera, po jedan za svaki broj od 0 do 9. Svaki primjer se sastoji od ulaznih vrijednosti i očekivanog izlaza. Ulazne vrijednosti su binarni prikazi brojeva, gdje 1 predstavlja crnu boju, a 0 bijelu boju. Očekivani izlaz je također binarni prikaz broja, gdje je samo jedan element 1, a svi ostali su 0. Na primjer, očekivani izlaz za broj 3 je [0, 0, 0, 1, 0, 0, 0, 0, 0, 0].
Nakon definiranja skupa podataka, stvaramo neuronsku mrežu pomoću new brain.NeuralNetwork() i definiramo jedan skriveni sloj s tri neurona. Zatim treniramo neuronsku mrežu pomoću net.train(trainingData), gdje se trainingData koristi kao skup podataka za treniranje.
Nakon što je mreža trenirana, možemo testirati njezinu točnost pomoću net.run(). U ovom primjeru, testiramo mrežu s novim podacima [1, 0, 0], što bi trebalo predstavljati broj 1. Očekivani izlaz je [0, 1, 0, 0, 0, 0, 0, 0, 0, 0], što predstavlja binarni prikaz broja 1. Rezultat se ispisuje u konzoli.
Ovo je samo jednostavan primjer, ali Brain.js se može koristiti za složenije zadatke kao što su prepoznavanje slika, klasifikacija teksta, predviđanje vrijednosti i mnogi drugi.
Evo još jednog primjera koda koji ilustrira kako koristiti Brain.js za predviđanje vrijednosti funkcije sinus:
// Učitavanje biblioteke Brain.js
const brain = require('brain.js');
// Definiranje skupa podataka za treniranje
const trainingData = [];
for (let i = 0; i < 100; i++) {
const input = { x: i / 100 };
const output = { y: Math.sin(input.x * Math.PI * 2) };
trainingData.push({ input, output });
}
// Definiranje neuronske mreže s jednim skrivenim slojem s pet neurona
const net = new brain.NeuralNetwork({ hiddenLayers: [5] });
// Treniranje neuronske mreže
net.train(trainingData);
// Testiranje neuronske mreže
const input = { x: 0.1 };
const output = net.run(input);
console.log(`Za ulaz ${input.x}, predviđena vrijednost je ${output.y}.`);
U ovom primjeru neuronska mreža uči kako predvidjeti vrijednosti funkcije sinus za ulazne vrijednosti od 0 do 1. Skup podataka za treniranje sastoji se od 100 primjera, gdje svaki primjer sadrži ulaz i očekivani izlaz. Ulaz je vrijednost x koja varira od 0 do 1 u koracima od 0.01, a izlaz je vrijednost y koju predstavlja sinus od x pomnožen s 2π.
Nakon definiranja skupa podataka, stvaramo neuronsku mrežu pomoću new brain.NeuralNetwork() i definiramo jedan skriveni sloj s pet neurona. Zatim treniramo neuronsku mrežu pomoću net.train(trainingData), gdje se trainingData koristi kao skup podataka za treniranje.
Nakon što je mreža trenirana, možemo testirati njezinu sposobnost predviđanja vrijednosti pomoću net.run(). U ovom primjeru, testiramo mrežu s novim podacima { x: 0.1 }, što bi trebalo predstavljati vrijednost sinus(0.1 * 2π). Rezultat se ispisuje u konzoli.
Evo još jednostavnijeg primjera koda koji ilustrira kako koristiti Brain.js za predviđanje izlaza funkcije AND:
// Učitavanje biblioteke Brain.js
const brain = require('brain.js');
// Definiranje skupa podataka za treniranje
const trainingData = [
{ input: [0, 0], output: [0] },
{ input: [0, 1], output: [0] },
{ input: [1, 0], output: [0] },
{ input: [1, 1], output: [1] },
];
// Definiranje neuronske mreže s jednim skrivenim slojem s tri neurona
const net = new brain.NeuralNetwork({ hiddenLayers: [3] });
// Treniranje neuronske mreže
net.train(trainingData);
// Testiranje neuronske mreže
const output1 = net.run([0, 0]); // [0]
const output2 = net.run([0, 1]); // [0]
const output3 = net.run([1, 0]); // [0]
const output4 = net.run([1, 1]); // [1]
console.log(output1, output2, output3, output4);
U ovom primjeru neuronska mreža uči kako predvidjeti izlaz funkcije AND za ulazne vrijednosti od 0 ili 1. Skup podataka za treniranje sastoji se od četiri primjera, gdje svaki primjer sadrži ulaz i očekivani izlaz. Ulaz je dva binarna broja (0 ili 1), a izlaz je također binarni broj koji predstavlja izlaz funkcije AND za dane ulazne vrijednosti.
Nakon definiranja skupa podataka, stvaramo neuronsku mrežu pomoću new brain.NeuralNetwork() i definiramo jedan skriveni sloj s tri neurona. Zatim treniramo neuronsku mrežu pomoću net.train(trainingData), gdje se trainingData koristi kao skup podataka za treniranje.
Nakon što je mreža trenirana, možemo testirati njezinu sposobnost predviđanja izlaza funkcije AND pomoću net.run(). U ovom primjeru, testiramo mrežu s nekoliko ulaznih vrijednosti i ispisujemo predviđene izlaze u konzoli.
Evo jednog primjera korištenja brain.recurrent.LSTM() za predviđanje sljedeće riječi u rečenici na temelju prethodnih riječi.
// Učitavanje biblioteke Brain.js
const brain = require('brain.js');
// Definiranje skupa podataka za treniranje
const trainingData = [
{
input: 'The cat is',
output: 'sleeping',
},
{
input: 'The dog is',
output: 'barking',
},
{
input: 'The bird is',
output: 'singing',
},
{
input: 'The fish is',
output: 'swimming',
},
];
// Definiranje neuronske mreže
const net = new brain.recurrent.LSTM();
// Treniranje neuronske mreže
net.train(trainingData, {
iterations: 2000,
errorThresh: 0.01,
});
// Predviđanje sljedeće riječi u rečenici
const output = net.run('The cat is');
console.log(output);
U ovom primjeru koristimo brain.recurrent.LSTM() da bismo naučili neuronsku mrežu predviđati sljedeću riječ u rečenici na temelju prethodnih riječi. Skup podataka za treniranje sastoji se od četiri primjera rečenica, gdje je svaka rečenica započeta nizom riječi koje su iste za sve primjere.
Nakon definiranja skupa podataka, stvaramo neuronsku mrežu pomoću new brain.recurrent.LSTM(). Kao i u prethodnom primjeru, ova neuronska mreža koristi LSTM arhitekturu.
Zatim treniramo neuronsku mrežu pomoću net.train(), gdje se trainingData koristi kao skup podataka za treniranje. Podešavamo iterations na 2000, što znači da će mreža proći kroz skup podataka za treniranje 2000 puta. Također postavljamo errorThresh na 0.01, što je prag pogreške koji neuronska mreža mora doseći pri treniranju.
Nakon što je mreža trenirana, možemo predvidjeti sljedeću riječ u rečenici pomoću net.run(). U ovom primjeru, predviđamo sljedeću riječ u rečenici koja započinje s nizom "The cat is". Rezultat će biti riječ "sleeping", koja se pojavljuje u skupu podataka za treniranje nakon niza riječi "The cat is".
Evo jednostavnog primjera korištenja brain.js za simuliranje bacanja kocke:
// Učitavanje biblioteke Brain.js
const brain = require('brain.js');
// Definiranje skupa podataka za treniranje
const trainingData = [
{
input: [1, 0, 0, 0, 0, 0],
output: [1, 0, 0, 0, 0, 0],
},
{
input: [0, 1, 0, 0, 0, 0],
output: [0, 1, 0, 0, 0, 0],
},
{
input: [0, 0, 1, 0, 0, 0],
output: [0, 0, 1, 0, 0, 0],
},
{
input: [0, 0, 0, 1, 0, 0],
output: [0, 0, 0, 1, 0, 0],
},
{
input: [0, 0, 0, 0, 1, 0],
output: [0, 0, 0, 0, 1, 0],
},
{
input: [0, 0, 0, 0, 0, 1],
output: [0, 0, 0, 0, 0, 1],
},
];
// Definiranje neuronske mreže
const net = new brain.NeuralNetwork();
// Treniranje neuronske mreže
net.train(trainingData);
// Generiranje slučajnog broja između 1 i 6
const roll = Math.floor(Math.random() * 6) + 1;
// Predviđanje izlaza za dobiveni ulaz
const output = net.run([roll === 1, roll === 2, roll === 3, roll === 4, roll === 5, roll === 6]);
// Ispisivanje rezultata
console.log(`Bacio si kocku i dobio ${roll}.`);
console.log(`Mreža predviđa da će sljedeći broj biti ${output.indexOf(Math.max(...output)) + 1}.`);
U ovom primjeru koristimo neuronsku mrežu kako bismo predvidjeli sljedeći broj koji će biti izbačen pri bacanju kocke. Skup podataka za treniranje sastoji se od 6 primjera, pri čemu svaki primjer odgovara jednom od mogućih izlaza kocke - brojevima od 1 do 6.
Nakon definiranja skupa podataka, stvaramo neuronsku mrežu pomoću new brain.NeuralNetwork(). Kao i u prethodnom primjeru, ova neuronska mreža koristi osnovnu arhitekturu s jednim skrivenim slojem.
Zatim treniramo neuronsku mrežu pomoću net.train(), gdje se trainingData koristi kao skup podataka za treniranje. Nakon što je mreža trenirana, generiramo slučajni broj između 1 i 6 pomoću Math.random() i Math.floor(). Zatim koristimo net.run() kako bismo predvidjeli sljedeći broj koji će biti izbačen na temelju dobivenog ulaza. Ovdje se ulaz sastoji od niza boolean vrijednosti koje odgovaraju svakom od mogućih brojeva koje kocka može izbaciti - ako smo dobili 1, na primjer, ulaz će biti [true, false, false, false, false, false]. Izlaz predstavlja niz vjerojatnosti za svaki od mogućih brojeva, pri čemu najveća vjerojatnost predstavlja predviđani broj.
Na kraju jednostavno ispisujemo dobiveni ulaz i predviđeni izlaz kako bismo vidjeli kako se neuronska mreža ponaša u praksi.
Važno je napomenuti da se u ovom primjeru neuronska mreža trenira samo na temelju vrlo malog skupa podataka i da nije savršeno točna u predviđanju sljedećeg broja. Međutim, ovo ilustrira osnovne principe korištenja brain.js za jednostavne probleme poput simulacije bacanja kocke.
Što znači hiddenLayers
hiddenLayers je parametar koji se koristi u brain.js prilikom inicijalizacije neuronske mreže kako bi se definirao broj i veličina skrivenih slojeva unutar neuronske mreže. Skriveni slojevi su slojevi između ulaza i izlaza, a njihova funkcija je da obrade ulazne podatke i generiraju izlazne podatke.
Ovaj parametar uzima niz brojeva koji predstavljaju veličinu skrivenih slojeva u neuronskoj mreži. Na primjer, ako koristimo brain.recurrent.LSTM neuronsku mrežu, a postavimo parametar hiddenLayers na [128, 64], to znači da će mreža imati dva skrivena sloja, prvi skriveni sloj s 128 neurona i drugi skriveni sloj s 64 neurona.
Veličina i broj skrivenih slojeva mogu značajno utjecati na performanse neuronske mreže. Složenije probleme može biti potrebno riješiti sa složenijim modelima koji imaju veći broj neurona u skrivenim slojevima. S druge strane, manji broj skrivenih slojeva i neurona može biti dovoljan za rješavanje jednostavnijih problema. Međutim, veličina i broj skrivenih slojeva također mogu utjecati na brzinu učenja i trajanje treniranja neuronske mreže, pa je potrebno balansirati performanse i brzinu učenja prilikom odabira veličine skrivenih slojeva.