mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2025-10-16 12:05:41 +00:00
521 lines
12 KiB
TypeScript
521 lines
12 KiB
TypeScript
// Neurons
|
|
// =======
|
|
namespace NeuronTests {
|
|
// project
|
|
// -------
|
|
var A = new Neuron();
|
|
var B = new Neuron();
|
|
A.project(B); // A now projects a connection to B
|
|
A.project(A); // Neurons can also self-connect
|
|
|
|
// gate
|
|
// ----
|
|
var A = new Neuron();
|
|
var B = new Neuron();
|
|
var connection = A.project(B);
|
|
|
|
var C = new Neuron();
|
|
C.gate(connection); // now C gates the connection between A and B
|
|
|
|
// activate
|
|
// --------
|
|
var A = new Neuron();
|
|
var B = new Neuron();
|
|
A.project(B);
|
|
|
|
A.activate(0.5); // 0.5
|
|
B.activate(); // 0.3244554645
|
|
|
|
// propagate
|
|
// ---------
|
|
var A = new Neuron();
|
|
var B = new Neuron();
|
|
A.project(B);
|
|
|
|
var learningRate = .3;
|
|
|
|
for (var i = 0; i < 20000; i++) {
|
|
// when A activates 1
|
|
A.activate(1);
|
|
|
|
// train B to activate 0
|
|
B.activate();
|
|
B.propagate(learningRate, 0);
|
|
}
|
|
|
|
// test it
|
|
A.activate(1);
|
|
B.activate(); // 0.006540565760853365
|
|
|
|
// squashing function and bias
|
|
var A = new Neuron();
|
|
A.squash = Neuron.squash.TANH;
|
|
A.bias = 1;
|
|
}
|
|
|
|
// Layers
|
|
// ======
|
|
namespace LayerTests {
|
|
// project
|
|
// -------
|
|
var A = new Layer(5);
|
|
var B = new Layer(3);
|
|
A.project(B, Layer.connectionType.ALL_TO_ALL); // All the neurons in layer A now project a connection to all the neurons in layer B
|
|
A.project(A, Layer.connectionType.ONE_TO_ONE);
|
|
|
|
// gate
|
|
// ----
|
|
var A = new Layer(5);
|
|
var B = new Layer(3);
|
|
var connection = A.project(B);
|
|
|
|
var C = new Layer(4);
|
|
C.gate(connection, Layer.gateType.INPUT); // now C gates the connection between A and B (input gate)
|
|
|
|
// activate
|
|
// --------
|
|
var A = new Layer(5);
|
|
var B = new Layer(3);
|
|
A.project(B);
|
|
|
|
A.activate([1, 0, 1, 0, 1]); // [1,0,1,0,1]
|
|
B.activate(); // [0.3280457, 0.83243247, 0.5320423]
|
|
|
|
// propagate
|
|
// ---------
|
|
var A = new Layer(5);
|
|
var B = new Layer(2);
|
|
A.project(B);
|
|
|
|
var learningRate = .3;
|
|
|
|
for (var i = 0; i < 20000; i++) {
|
|
// when A activates [1, 0, 1, 0, 1]
|
|
A.activate([1, 0, 1, 0, 1]);
|
|
|
|
// train B to activate [0,0]
|
|
B.activate();
|
|
B.propagate(learningRate, [0, 0]);
|
|
}
|
|
|
|
// test it
|
|
A.activate([1, 0, 1, 0, 1]);
|
|
B.activate(); // [0.004606949693864496, 0.004606763721459169]
|
|
|
|
// squashing function and bias
|
|
A.set({
|
|
squash: Neuron.squash.TANH,
|
|
bias: 0
|
|
})
|
|
|
|
// neurons
|
|
// -------
|
|
A.neurons();
|
|
}
|
|
|
|
// Networks
|
|
// ========
|
|
|
|
namespace NetworkTests {
|
|
var inputLayer = new Layer(4);
|
|
var hiddenLayer = new Layer(6);
|
|
var outputLayer = new Layer(2);
|
|
|
|
inputLayer.project(hiddenLayer);
|
|
hiddenLayer.project(outputLayer);
|
|
|
|
var A = new Network({
|
|
input: inputLayer,
|
|
hidden: [hiddenLayer],
|
|
output: outputLayer
|
|
});
|
|
|
|
var B = new Network({
|
|
input: inputLayer,
|
|
hidden: [hiddenLayer],
|
|
output: outputLayer
|
|
});
|
|
|
|
// project
|
|
// -------
|
|
A.project(B, Layer.connectionType.ALL_TO_ALL);
|
|
|
|
// gate
|
|
// ----
|
|
|
|
var C = new Network({
|
|
input: inputLayer,
|
|
hidden: [hiddenLayer],
|
|
output: outputLayer
|
|
});
|
|
var connection = A.project(B);
|
|
C.gate(connection, Layer.gateType.INPUT); // now C's output layer gates the connection between A's output layer and B's input layer (input gate)
|
|
|
|
// activate
|
|
// --------
|
|
var inputLayer = new Layer(4);
|
|
var hiddenLayer = new Layer(6);
|
|
var outputLayer = new Layer(2);
|
|
|
|
inputLayer.project(hiddenLayer);
|
|
hiddenLayer.project(outputLayer);
|
|
|
|
var myNetwork = new Network({
|
|
input: inputLayer,
|
|
hidden: [hiddenLayer],
|
|
output: outputLayer
|
|
});
|
|
|
|
myNetwork.activate([1, 0, 1, 0]); // [0.5200553602396137, 0.4792707231811006]
|
|
|
|
// propagate
|
|
// ---------
|
|
// create the network
|
|
var inputLayer = new Layer(2);
|
|
var hiddenLayer = new Layer(3);
|
|
var outputLayer = new Layer(1);
|
|
|
|
inputLayer.project(hiddenLayer);
|
|
hiddenLayer.project(outputLayer);
|
|
|
|
var myNetwork = new Network({
|
|
input: inputLayer,
|
|
hidden: [hiddenLayer],
|
|
output: outputLayer
|
|
});
|
|
|
|
// train the network
|
|
var learningRate = .3;
|
|
for (var i = 0; i < 20000; i++) {
|
|
// 0,0 => 0
|
|
myNetwork.activate([0, 0]);
|
|
myNetwork.propagate(learningRate, [0]);
|
|
|
|
// 0,1 => 1
|
|
myNetwork.activate([0, 1]);
|
|
myNetwork.propagate(learningRate, [1]);
|
|
|
|
// 1,0 => 1
|
|
myNetwork.activate([1, 0]);
|
|
myNetwork.propagate(learningRate, [1]);
|
|
|
|
// 1,1 => 0
|
|
myNetwork.activate([1, 1]);
|
|
myNetwork.propagate(learningRate, [0]);
|
|
}
|
|
|
|
// test the network
|
|
myNetwork.activate([0, 0]); // [0.015020775950893527]
|
|
myNetwork.activate([0, 1]); // [0.9815816381088985]
|
|
myNetwork.activate([1, 0]); // [0.9871822457132193]
|
|
myNetwork.activate([1, 1]); // [0.012950087641929467]
|
|
|
|
// optimize
|
|
// --------
|
|
|
|
// extend
|
|
// ------
|
|
|
|
// toJSON/fromJSON
|
|
// ---------------
|
|
var exported = myNetwork.toJSON();
|
|
var imported = Network.fromJSON(exported);
|
|
|
|
// worker
|
|
// ------
|
|
// training set
|
|
var learningRate = .3;
|
|
var trainingSet = [
|
|
{
|
|
input: [0, 0],
|
|
output: [0]
|
|
},
|
|
{
|
|
input: [0, 1],
|
|
output: [1]
|
|
},
|
|
{
|
|
input: [1, 0],
|
|
output: [1]
|
|
},
|
|
{
|
|
input: [1, 1],
|
|
output: [0]
|
|
},
|
|
];
|
|
|
|
// create a network
|
|
var inputLayer = new Layer(2);
|
|
var hiddenLayer = new Layer(3);
|
|
var outputLayer = new Layer(1);
|
|
|
|
inputLayer.project(hiddenLayer);
|
|
hiddenLayer.project(outputLayer);
|
|
|
|
var myNetwork = new Network({
|
|
input: inputLayer,
|
|
hidden: [hiddenLayer],
|
|
output: outputLayer
|
|
});
|
|
|
|
// create a worker
|
|
var myWorker = myNetwork.worker();
|
|
|
|
// activate the network
|
|
function activateWorker(input: number[]) {
|
|
myWorker.postMessage({
|
|
action: "activate",
|
|
input: input,
|
|
memoryBuffer: myNetwork.optimized.memory
|
|
}, [myNetwork.optimized.memory.buffer]);
|
|
}
|
|
|
|
// backpropagate the network
|
|
function propagateWorker(target: number[]) {
|
|
myWorker.postMessage({
|
|
action: "propagate",
|
|
target: target,
|
|
rate: learningRate,
|
|
memoryBuffer: myNetwork.optimized.memory
|
|
}, [myNetwork.optimized.memory.buffer]);
|
|
}
|
|
|
|
// train the worker
|
|
myWorker.onmessage = function (e) {
|
|
// give control of the memory back to the network - this is mandatory!
|
|
myNetwork.optimized.ownership(e.data.memoryBuffer);
|
|
|
|
if (e.data.action == "propagate") {
|
|
if (index >= 4) {
|
|
index = 0;
|
|
iterations++;
|
|
if (iterations % 100 == 0) {
|
|
var output00 = myNetwork.activate([0, 0]);
|
|
var output01 = myNetwork.activate([0, 1]);
|
|
var output10 = myNetwork.activate([1, 0]);
|
|
var output11 = myNetwork.activate([1, 1]);
|
|
|
|
console.log("0,0 => ", output00);
|
|
console.log("0,1 => ", output01);
|
|
console.log("1,0 => ", output10);
|
|
console.log("1,1 => ", output11, "\n");
|
|
}
|
|
}
|
|
|
|
activateWorker(trainingSet[index].input);
|
|
}
|
|
|
|
if (e.data.action == "activate") {
|
|
propagateWorker(trainingSet[index].output);
|
|
index++;
|
|
}
|
|
}
|
|
|
|
// kick it
|
|
var index = 0;
|
|
var iterations = 0;
|
|
activateWorker(trainingSet[index].input);
|
|
|
|
// standalone
|
|
// ----------
|
|
var inputLayer = new Layer(4);
|
|
var hiddenLayer = new Layer(6);
|
|
var outputLayer = new Layer(2);
|
|
|
|
inputLayer.project(hiddenLayer);
|
|
hiddenLayer.project(outputLayer);
|
|
|
|
var myNetwork = new Network({
|
|
input: inputLayer,
|
|
hidden: [hiddenLayer],
|
|
output: outputLayer
|
|
});
|
|
|
|
var standalone = myNetwork.standalone();
|
|
|
|
myNetwork.activate([1, 0, 1, 0]); // [0.5466397925108878, 0.5121246668637663]
|
|
standalone([1, 0, 1, 0]); // [0.5466397925108878, 0.5121246668637663]
|
|
|
|
// clone
|
|
// -----
|
|
var inputLayer = new Layer(4);
|
|
var hiddenLayer = new Layer(6);
|
|
var outputLayer = new Layer(2);
|
|
|
|
inputLayer.project(hiddenLayer);
|
|
hiddenLayer.project(outputLayer);
|
|
|
|
var myNetwork = new Network({
|
|
input: inputLayer,
|
|
hidden: [hiddenLayer],
|
|
output: outputLayer
|
|
});
|
|
|
|
var clone = myNetwork.clone();
|
|
|
|
myNetwork.activate([1, 0, 1, 0]); // [0.5466397925108878, 0.5121246668637663]
|
|
clone.activate([1, 0, 1, 0]); // [0.5466397925108878, 0.5121246668637663]
|
|
|
|
// neurons
|
|
// -------
|
|
myNetwork.neurons();
|
|
|
|
// set
|
|
// ---
|
|
var inputLayer = new Layer(4);
|
|
var hiddenLayer = new Layer(6);
|
|
var outputLayer = new Layer(2);
|
|
|
|
inputLayer.project(hiddenLayer);
|
|
hiddenLayer.project(outputLayer);
|
|
|
|
var myNetwork = new Network();
|
|
|
|
myNetwork.set({
|
|
input: inputLayer,
|
|
hidden: [hiddenLayer],
|
|
output: outputLayer
|
|
});
|
|
}
|
|
|
|
// Architect
|
|
// =========
|
|
namespace ArchitectTests {
|
|
// Perceptron
|
|
// ----------
|
|
var myPerceptron = new Architect.Perceptron(2, 3, 1);
|
|
|
|
// LSTM
|
|
// ----
|
|
var myLSTM = new Architect.LSTM(2, 6, 1);
|
|
|
|
// Liquid
|
|
// ------
|
|
var input = 2;
|
|
var pool = 20;
|
|
var output = 1;
|
|
var connections = 30;
|
|
var gates = 10;
|
|
|
|
var myLiquidStateMachine = new Architect.Liquid(input, pool, output, connections, gates);
|
|
|
|
// Hopfield
|
|
// --------
|
|
var hopfield = new Architect.Hopfield(10) // create a network for 10-bit patterns
|
|
|
|
// teach the network two different patterns
|
|
hopfield.learn([
|
|
[0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
|
|
[1, 1, 1, 1, 1, 0, 0, 0, 0, 0]
|
|
])
|
|
|
|
// feed new patterns to the network and it will return the most similar to the ones it was trained to remember
|
|
hopfield.feed([0, 1, 0, 1, 0, 1, 0, 1, 1, 1]) // [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
|
|
hopfield.feed([1, 1, 1, 1, 1, 0, 0, 1, 0, 0]) // [1, 1, 1, 1, 1, 0, 0, 0, 0, 0]
|
|
}
|
|
|
|
// Trainer
|
|
// =======
|
|
namespace TrainerTests {
|
|
// train
|
|
// -----
|
|
var myNetwork = new Architect.Perceptron(2, 2, 1)
|
|
var trainer = new Trainer(myNetwork)
|
|
|
|
var trainingSet = [
|
|
{
|
|
input: [0, 0],
|
|
output: [0]
|
|
},
|
|
{
|
|
input: [0, 1],
|
|
output: [1]
|
|
},
|
|
{
|
|
input: [1, 0],
|
|
output: [1]
|
|
},
|
|
{
|
|
input: [1, 1],
|
|
output: [0]
|
|
},
|
|
]
|
|
|
|
trainer.train(trainingSet);
|
|
|
|
var traningOptions = {
|
|
rate: .1,
|
|
iterations: 20000,
|
|
error: .005,
|
|
shuffle: true,
|
|
log: 1000,
|
|
cost: Trainer.cost.CROSS_ENTROPY,
|
|
schedule: {
|
|
every: 500, // repeat this task every 500 iterations
|
|
do: function (data: Synaptic.Trainer.TrainingScheduleDoData) {
|
|
// custom log
|
|
console.log("error", data.error, "iterations", data.iterations, "rate", data.rate);
|
|
if (data.error > .5)
|
|
return true; // abort/stop training
|
|
}
|
|
}
|
|
};
|
|
|
|
trainer.train(trainingSet, traningOptions);
|
|
|
|
// trainAsync
|
|
// ----------
|
|
var trainer = new Trainer(myNetwork);
|
|
trainer.trainAsync(trainingSet, traningOptions)
|
|
.then((results: any) => console.log('done!', results))
|
|
|
|
var myNetwork = new Architect.Perceptron(2, 2, 1)
|
|
var trainer = new Trainer(myNetwork)
|
|
|
|
var trainingSet = [
|
|
{
|
|
input: [0, 0],
|
|
output: [0]
|
|
},
|
|
{
|
|
input: [0, 1],
|
|
output: [1]
|
|
},
|
|
{
|
|
input: [1, 0],
|
|
output: [1]
|
|
},
|
|
{
|
|
input: [1, 1],
|
|
output: [0]
|
|
},
|
|
]
|
|
|
|
trainer.trainAsync(trainingSet)
|
|
.then((results: any) => console.log('done!', results))
|
|
|
|
// test
|
|
// ----
|
|
|
|
// XOR
|
|
// ---
|
|
var trainer = new Trainer(myNetwork);
|
|
trainer.XOR(); // {error: 0.004999821588193305, iterations: 21333, time: 111}
|
|
|
|
// DSR
|
|
// ---
|
|
trainer.DSR({
|
|
targets: [2, 4],
|
|
distractors: [3, 5],
|
|
prompts: [0, 1],
|
|
length: 10
|
|
});
|
|
|
|
// ERG
|
|
// ---
|
|
trainer.ERG();
|
|
|
|
// timingTask
|
|
// ----------
|
|
}
|