3033 lines
106 KiB
JavaScript
3033 lines
106 KiB
JavaScript
|
import {
|
||
|
|
__commonJS,
|
||
|
|
__esm,
|
||
|
|
__export
|
||
|
|
} from "./chunk-ELXAK55F.js";
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/methods/activation.js
|
||
|
|
var require_activation = __commonJS({
|
||
|
|
"node_modules/neataptic/src/methods/activation.js"(exports, module) {
|
||
|
|
var activation = {
|
||
|
|
LOGISTIC: function(x, derivate) {
|
||
|
|
var fx = 1 / (1 + Math.exp(-x));
|
||
|
|
if (!derivate)
|
||
|
|
return fx;
|
||
|
|
return fx * (1 - fx);
|
||
|
|
},
|
||
|
|
TANH: function(x, derivate) {
|
||
|
|
if (derivate)
|
||
|
|
return 1 - Math.pow(Math.tanh(x), 2);
|
||
|
|
return Math.tanh(x);
|
||
|
|
},
|
||
|
|
IDENTITY: function(x, derivate) {
|
||
|
|
return derivate ? 1 : x;
|
||
|
|
},
|
||
|
|
STEP: function(x, derivate) {
|
||
|
|
return derivate ? 0 : x > 0 ? 1 : 0;
|
||
|
|
},
|
||
|
|
RELU: function(x, derivate) {
|
||
|
|
if (derivate)
|
||
|
|
return x > 0 ? 1 : 0;
|
||
|
|
return x > 0 ? x : 0;
|
||
|
|
},
|
||
|
|
SOFTSIGN: function(x, derivate) {
|
||
|
|
var d = 1 + Math.abs(x);
|
||
|
|
if (derivate)
|
||
|
|
return x / Math.pow(d, 2);
|
||
|
|
return x / d;
|
||
|
|
},
|
||
|
|
SINUSOID: function(x, derivate) {
|
||
|
|
if (derivate)
|
||
|
|
return Math.cos(x);
|
||
|
|
return Math.sin(x);
|
||
|
|
},
|
||
|
|
GAUSSIAN: function(x, derivate) {
|
||
|
|
var d = Math.exp(-Math.pow(x, 2));
|
||
|
|
if (derivate)
|
||
|
|
return -2 * x * d;
|
||
|
|
return d;
|
||
|
|
},
|
||
|
|
BENT_IDENTITY: function(x, derivate) {
|
||
|
|
var d = Math.sqrt(Math.pow(x, 2) + 1);
|
||
|
|
if (derivate)
|
||
|
|
return x / (2 * d) + 1;
|
||
|
|
return (d - 1) / 2 + x;
|
||
|
|
},
|
||
|
|
BIPOLAR: function(x, derivate) {
|
||
|
|
return derivate ? 0 : x > 0 ? 1 : -1;
|
||
|
|
},
|
||
|
|
BIPOLAR_SIGMOID: function(x, derivate) {
|
||
|
|
var d = 2 / (1 + Math.exp(-x)) - 1;
|
||
|
|
if (derivate)
|
||
|
|
return 1 / 2 * (1 + d) * (1 - d);
|
||
|
|
return d;
|
||
|
|
},
|
||
|
|
HARD_TANH: function(x, derivate) {
|
||
|
|
if (derivate)
|
||
|
|
return x > -1 && x < 1 ? 1 : 0;
|
||
|
|
return Math.max(-1, Math.min(1, x));
|
||
|
|
},
|
||
|
|
ABSOLUTE: function(x, derivate) {
|
||
|
|
if (derivate)
|
||
|
|
return x < 0 ? -1 : 1;
|
||
|
|
return Math.abs(x);
|
||
|
|
},
|
||
|
|
INVERSE: function(x, derivate) {
|
||
|
|
if (derivate)
|
||
|
|
return -1;
|
||
|
|
return 1 - x;
|
||
|
|
},
|
||
|
|
SELU: function(x, derivate) {
|
||
|
|
var alpha = 1.6732632423543772;
|
||
|
|
var scale = 1.0507009873554805;
|
||
|
|
var fx = x > 0 ? x : alpha * Math.exp(x) - alpha;
|
||
|
|
if (derivate) {
|
||
|
|
return x > 0 ? scale : (fx + alpha) * scale;
|
||
|
|
}
|
||
|
|
return fx * scale;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
module.exports = activation;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/methods/mutation.js
|
||
|
|
var require_mutation = __commonJS({
|
||
|
|
"node_modules/neataptic/src/methods/mutation.js"(exports, module) {
|
||
|
|
var activation = require_activation();
|
||
|
|
var mutation = {
|
||
|
|
ADD_NODE: {
|
||
|
|
name: "ADD_NODE"
|
||
|
|
},
|
||
|
|
SUB_NODE: {
|
||
|
|
name: "SUB_NODE",
|
||
|
|
keep_gates: true
|
||
|
|
},
|
||
|
|
ADD_CONN: {
|
||
|
|
name: "ADD_CONN"
|
||
|
|
},
|
||
|
|
SUB_CONN: {
|
||
|
|
name: "REMOVE_CONN"
|
||
|
|
},
|
||
|
|
MOD_WEIGHT: {
|
||
|
|
name: "MOD_WEIGHT",
|
||
|
|
min: -1,
|
||
|
|
max: 1
|
||
|
|
},
|
||
|
|
MOD_BIAS: {
|
||
|
|
name: "MOD_BIAS",
|
||
|
|
min: -1,
|
||
|
|
max: 1
|
||
|
|
},
|
||
|
|
MOD_ACTIVATION: {
|
||
|
|
name: "MOD_ACTIVATION",
|
||
|
|
mutateOutput: true,
|
||
|
|
allowed: [
|
||
|
|
activation.LOGISTIC,
|
||
|
|
activation.TANH,
|
||
|
|
activation.RELU,
|
||
|
|
activation.IDENTITY,
|
||
|
|
activation.STEP,
|
||
|
|
activation.SOFTSIGN,
|
||
|
|
activation.SINUSOID,
|
||
|
|
activation.GAUSSIAN,
|
||
|
|
activation.BENT_IDENTITY,
|
||
|
|
activation.BIPOLAR,
|
||
|
|
activation.BIPOLAR_SIGMOID,
|
||
|
|
activation.HARD_TANH,
|
||
|
|
activation.ABSOLUTE,
|
||
|
|
activation.INVERSE,
|
||
|
|
activation.SELU
|
||
|
|
]
|
||
|
|
},
|
||
|
|
ADD_SELF_CONN: {
|
||
|
|
name: "ADD_SELF_CONN"
|
||
|
|
},
|
||
|
|
SUB_SELF_CONN: {
|
||
|
|
name: "SUB_SELF_CONN"
|
||
|
|
},
|
||
|
|
ADD_GATE: {
|
||
|
|
name: "ADD_GATE"
|
||
|
|
},
|
||
|
|
SUB_GATE: {
|
||
|
|
name: "SUB_GATE"
|
||
|
|
},
|
||
|
|
ADD_BACK_CONN: {
|
||
|
|
name: "ADD_BACK_CONN"
|
||
|
|
},
|
||
|
|
SUB_BACK_CONN: {
|
||
|
|
name: "SUB_BACK_CONN"
|
||
|
|
},
|
||
|
|
SWAP_NODES: {
|
||
|
|
name: "SWAP_NODES",
|
||
|
|
mutateOutput: true
|
||
|
|
}
|
||
|
|
};
|
||
|
|
mutation.ALL = [
|
||
|
|
mutation.ADD_NODE,
|
||
|
|
mutation.SUB_NODE,
|
||
|
|
mutation.ADD_CONN,
|
||
|
|
mutation.SUB_CONN,
|
||
|
|
mutation.MOD_WEIGHT,
|
||
|
|
mutation.MOD_BIAS,
|
||
|
|
mutation.MOD_ACTIVATION,
|
||
|
|
mutation.ADD_GATE,
|
||
|
|
mutation.SUB_GATE,
|
||
|
|
mutation.ADD_SELF_CONN,
|
||
|
|
mutation.SUB_SELF_CONN,
|
||
|
|
mutation.ADD_BACK_CONN,
|
||
|
|
mutation.SUB_BACK_CONN,
|
||
|
|
mutation.SWAP_NODES
|
||
|
|
];
|
||
|
|
mutation.FFW = [
|
||
|
|
mutation.ADD_NODE,
|
||
|
|
mutation.SUB_NODE,
|
||
|
|
mutation.ADD_CONN,
|
||
|
|
mutation.SUB_CONN,
|
||
|
|
mutation.MOD_WEIGHT,
|
||
|
|
mutation.MOD_BIAS,
|
||
|
|
mutation.MOD_ACTIVATION,
|
||
|
|
mutation.SWAP_NODES
|
||
|
|
];
|
||
|
|
module.exports = mutation;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/methods/selection.js
|
||
|
|
var require_selection = __commonJS({
|
||
|
|
"node_modules/neataptic/src/methods/selection.js"(exports, module) {
|
||
|
|
var selection = {
|
||
|
|
FITNESS_PROPORTIONATE: {
|
||
|
|
name: "FITNESS_PROPORTIONATE"
|
||
|
|
},
|
||
|
|
POWER: {
|
||
|
|
name: "POWER",
|
||
|
|
power: 4
|
||
|
|
},
|
||
|
|
TOURNAMENT: {
|
||
|
|
name: "TOURNAMENT",
|
||
|
|
size: 5,
|
||
|
|
probability: 0.5
|
||
|
|
}
|
||
|
|
};
|
||
|
|
module.exports = selection;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/methods/crossover.js
|
||
|
|
var require_crossover = __commonJS({
|
||
|
|
"node_modules/neataptic/src/methods/crossover.js"(exports, module) {
|
||
|
|
var crossover = {
|
||
|
|
SINGLE_POINT: {
|
||
|
|
name: "SINGLE_POINT",
|
||
|
|
config: [0.4]
|
||
|
|
},
|
||
|
|
TWO_POINT: {
|
||
|
|
name: "TWO_POINT",
|
||
|
|
config: [0.4, 0.9]
|
||
|
|
},
|
||
|
|
UNIFORM: {
|
||
|
|
name: "UNIFORM"
|
||
|
|
},
|
||
|
|
AVERAGE: {
|
||
|
|
name: "AVERAGE"
|
||
|
|
}
|
||
|
|
};
|
||
|
|
module.exports = crossover;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/methods/cost.js
|
||
|
|
var require_cost = __commonJS({
|
||
|
|
"node_modules/neataptic/src/methods/cost.js"(exports, module) {
|
||
|
|
var cost = {
|
||
|
|
CROSS_ENTROPY: function(target, output) {
|
||
|
|
var error = 0;
|
||
|
|
for (var i = 0; i < output.length; i++) {
|
||
|
|
error -= target[i] * Math.log(Math.max(output[i], 1e-15)) + (1 - target[i]) * Math.log(1 - Math.max(output[i], 1e-15));
|
||
|
|
}
|
||
|
|
return error / output.length;
|
||
|
|
},
|
||
|
|
MSE: function(target, output) {
|
||
|
|
var error = 0;
|
||
|
|
for (var i = 0; i < output.length; i++) {
|
||
|
|
error += Math.pow(target[i] - output[i], 2);
|
||
|
|
}
|
||
|
|
return error / output.length;
|
||
|
|
},
|
||
|
|
BINARY: function(target, output) {
|
||
|
|
var misses = 0;
|
||
|
|
for (var i = 0; i < output.length; i++) {
|
||
|
|
misses += Math.round(target[i] * 2) !== Math.round(output[i] * 2);
|
||
|
|
}
|
||
|
|
return misses;
|
||
|
|
},
|
||
|
|
MAE: function(target, output) {
|
||
|
|
var error = 0;
|
||
|
|
for (var i = 0; i < output.length; i++) {
|
||
|
|
error += Math.abs(target[i] - output[i]);
|
||
|
|
}
|
||
|
|
return error / output.length;
|
||
|
|
},
|
||
|
|
MAPE: function(target, output) {
|
||
|
|
var error = 0;
|
||
|
|
for (var i = 0; i < output.length; i++) {
|
||
|
|
error += Math.abs((output[i] - target[i]) / Math.max(target[i], 1e-15));
|
||
|
|
}
|
||
|
|
return error / output.length;
|
||
|
|
},
|
||
|
|
MSLE: function(target, output) {
|
||
|
|
var error = 0;
|
||
|
|
for (var i = 0; i < output.length; i++) {
|
||
|
|
error += Math.log(Math.max(target[i], 1e-15)) - Math.log(Math.max(output[i], 1e-15));
|
||
|
|
}
|
||
|
|
return error;
|
||
|
|
},
|
||
|
|
HINGE: function(target, output) {
|
||
|
|
var error = 0;
|
||
|
|
for (var i = 0; i < output.length; i++) {
|
||
|
|
error += Math.max(0, 1 - target[i] * output[i]);
|
||
|
|
}
|
||
|
|
return error;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
module.exports = cost;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/methods/gating.js
|
||
|
|
var require_gating = __commonJS({
|
||
|
|
"node_modules/neataptic/src/methods/gating.js"(exports, module) {
|
||
|
|
var gating = {
|
||
|
|
OUTPUT: {
|
||
|
|
name: "OUTPUT"
|
||
|
|
},
|
||
|
|
INPUT: {
|
||
|
|
name: "INPUT"
|
||
|
|
},
|
||
|
|
SELF: {
|
||
|
|
name: "SELF"
|
||
|
|
}
|
||
|
|
};
|
||
|
|
module.exports = gating;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/methods/connection.js
|
||
|
|
var require_connection = __commonJS({
|
||
|
|
"node_modules/neataptic/src/methods/connection.js"(exports, module) {
|
||
|
|
var connection = {
|
||
|
|
ALL_TO_ALL: {
|
||
|
|
name: "OUTPUT"
|
||
|
|
},
|
||
|
|
ALL_TO_ELSE: {
|
||
|
|
name: "INPUT"
|
||
|
|
},
|
||
|
|
ONE_TO_ONE: {
|
||
|
|
name: "SELF"
|
||
|
|
}
|
||
|
|
};
|
||
|
|
module.exports = connection;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/methods/rate.js
|
||
|
|
var require_rate = __commonJS({
|
||
|
|
"node_modules/neataptic/src/methods/rate.js"(exports, module) {
|
||
|
|
var rate = {
|
||
|
|
FIXED: function() {
|
||
|
|
var func = function(baseRate, iteration) {
|
||
|
|
return baseRate;
|
||
|
|
};
|
||
|
|
return func;
|
||
|
|
},
|
||
|
|
STEP: function(gamma, stepSize) {
|
||
|
|
gamma = gamma || 0.9;
|
||
|
|
stepSize = stepSize || 100;
|
||
|
|
var func = function(baseRate, iteration) {
|
||
|
|
return baseRate * Math.pow(gamma, Math.floor(iteration / stepSize));
|
||
|
|
};
|
||
|
|
return func;
|
||
|
|
},
|
||
|
|
EXP: function(gamma) {
|
||
|
|
gamma = gamma || 0.999;
|
||
|
|
var func = function(baseRate, iteration) {
|
||
|
|
return baseRate * Math.pow(gamma, iteration);
|
||
|
|
};
|
||
|
|
return func;
|
||
|
|
},
|
||
|
|
INV: function(gamma, power) {
|
||
|
|
gamma = gamma || 1e-3;
|
||
|
|
power = power || 2;
|
||
|
|
var func = function(baseRate, iteration) {
|
||
|
|
return baseRate * Math.pow(1 + gamma * iteration, -power);
|
||
|
|
};
|
||
|
|
return func;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
module.exports = rate;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/methods/methods.js
|
||
|
|
var require_methods = __commonJS({
|
||
|
|
"node_modules/neataptic/src/methods/methods.js"(exports, module) {
|
||
|
|
var methods = {
|
||
|
|
activation: require_activation(),
|
||
|
|
mutation: require_mutation(),
|
||
|
|
selection: require_selection(),
|
||
|
|
crossover: require_crossover(),
|
||
|
|
cost: require_cost(),
|
||
|
|
gating: require_gating(),
|
||
|
|
connection: require_connection(),
|
||
|
|
rate: require_rate()
|
||
|
|
};
|
||
|
|
module.exports = methods;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/architecture/connection.js
|
||
|
|
var require_connection2 = __commonJS({
|
||
|
|
"node_modules/neataptic/src/architecture/connection.js"(exports, module) {
|
||
|
|
module.exports = Connection;
|
||
|
|
function Connection(from, to, weight) {
|
||
|
|
this.from = from;
|
||
|
|
this.to = to;
|
||
|
|
this.gain = 1;
|
||
|
|
this.weight = typeof weight === "undefined" ? Math.random() * 0.2 - 0.1 : weight;
|
||
|
|
this.gater = null;
|
||
|
|
this.elegibility = 0;
|
||
|
|
this.previousDeltaWeight = 0;
|
||
|
|
this.totalDeltaWeight = 0;
|
||
|
|
this.xtrace = {
|
||
|
|
nodes: [],
|
||
|
|
values: []
|
||
|
|
};
|
||
|
|
}
|
||
|
|
Connection.prototype = {
|
||
|
|
toJSON: function() {
|
||
|
|
var json = {
|
||
|
|
weight: this.weight
|
||
|
|
};
|
||
|
|
return json;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Connection.innovationID = function(a, b) {
|
||
|
|
return 1 / 2 * (a + b) * (a + b + 1) + b;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// browser-external:child_process
|
||
|
|
var child_process_exports = {};
|
||
|
|
__export(child_process_exports, {
|
||
|
|
default: () => child_process_default
|
||
|
|
});
|
||
|
|
var child_process_default;
|
||
|
|
var init_child_process = __esm({
|
||
|
|
"browser-external:child_process"() {
|
||
|
|
child_process_default = new Proxy({}, {
|
||
|
|
get() {
|
||
|
|
throw new Error('Module "child_process" has been externalized for browser compatibility and cannot be accessed in client code.');
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// browser-external:path
|
||
|
|
var path_exports = {};
|
||
|
|
__export(path_exports, {
|
||
|
|
default: () => path_default
|
||
|
|
});
|
||
|
|
var path_default;
|
||
|
|
var init_path = __esm({
|
||
|
|
"browser-external:path"() {
|
||
|
|
path_default = new Proxy({}, {
|
||
|
|
get() {
|
||
|
|
throw new Error('Module "path" has been externalized for browser compatibility and cannot be accessed in client code.');
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/multithreading/workers/node/testworker.js
|
||
|
|
var require_testworker = __commonJS({
|
||
|
|
"node_modules/neataptic/src/multithreading/workers/node/testworker.js"(exports, module) {
|
||
|
|
module.exports = TestWorker;
|
||
|
|
var cp = (init_child_process(), child_process_exports);
|
||
|
|
var path = (init_path(), path_exports);
|
||
|
|
function TestWorker(dataSet, cost) {
|
||
|
|
this.worker = cp.fork(path.join(__dirname, "/worker"));
|
||
|
|
this.worker.send({ set: dataSet, cost: cost.name });
|
||
|
|
}
|
||
|
|
TestWorker.prototype = {
|
||
|
|
evaluate: function(network) {
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
var serialized = network.serialize();
|
||
|
|
var data = {
|
||
|
|
activations: serialized[0],
|
||
|
|
states: serialized[1],
|
||
|
|
conns: serialized[2]
|
||
|
|
};
|
||
|
|
var _that = this.worker;
|
||
|
|
this.worker.on("message", function callback(e) {
|
||
|
|
_that.removeListener("message", callback);
|
||
|
|
resolve(e);
|
||
|
|
});
|
||
|
|
this.worker.send(data);
|
||
|
|
});
|
||
|
|
},
|
||
|
|
terminate: function() {
|
||
|
|
this.worker.kill();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/multithreading/workers/browser/testworker.js
|
||
|
|
var require_testworker2 = __commonJS({
|
||
|
|
"node_modules/neataptic/src/multithreading/workers/browser/testworker.js"(exports, module) {
|
||
|
|
module.exports = TestWorker;
|
||
|
|
var multi = require_multi();
|
||
|
|
function TestWorker(dataSet, cost) {
|
||
|
|
var blob = new Blob([this._createBlobString(cost)]);
|
||
|
|
this.url = window.URL.createObjectURL(blob);
|
||
|
|
this.worker = new Worker(this.url);
|
||
|
|
var data = { set: new Float64Array(dataSet).buffer };
|
||
|
|
this.worker.postMessage(data, [data.set]);
|
||
|
|
}
|
||
|
|
TestWorker.prototype = {
|
||
|
|
evaluate: function(network) {
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
var serialized = network.serialize();
|
||
|
|
var data = {
|
||
|
|
activations: new Float64Array(serialized[0]).buffer,
|
||
|
|
states: new Float64Array(serialized[1]).buffer,
|
||
|
|
conns: new Float64Array(serialized[2]).buffer
|
||
|
|
};
|
||
|
|
this.worker.onmessage = function(e) {
|
||
|
|
var error = new Float64Array(e.data.buffer)[0];
|
||
|
|
resolve(error);
|
||
|
|
};
|
||
|
|
this.worker.postMessage(data, [data.activations, data.states, data.conns]);
|
||
|
|
});
|
||
|
|
},
|
||
|
|
terminate: function() {
|
||
|
|
this.worker.terminate();
|
||
|
|
window.URL.revokeObjectURL(this.url);
|
||
|
|
},
|
||
|
|
_createBlobString: function(cost) {
|
||
|
|
var source = `
|
||
|
|
var F = [${multi.activations.toString()}];
|
||
|
|
var cost = ${cost.toString()};
|
||
|
|
var multi = {
|
||
|
|
deserializeDataSet: ${multi.deserializeDataSet.toString()},
|
||
|
|
testSerializedSet: ${multi.testSerializedSet.toString()},
|
||
|
|
activateSerializedNetwork: ${multi.activateSerializedNetwork.toString()}
|
||
|
|
};
|
||
|
|
|
||
|
|
this.onmessage = function (e) {
|
||
|
|
if(typeof e.data.set === 'undefined'){
|
||
|
|
var A = new Float64Array(e.data.activations);
|
||
|
|
var S = new Float64Array(e.data.states);
|
||
|
|
var data = new Float64Array(e.data.conns);
|
||
|
|
|
||
|
|
var error = multi.testSerializedSet(set, cost, A, S, data, F);
|
||
|
|
|
||
|
|
var answer = { buffer: new Float64Array([error ]).buffer };
|
||
|
|
postMessage(answer, [answer.buffer]);
|
||
|
|
} else {
|
||
|
|
set = multi.deserializeDataSet(new Float64Array(e.data.set));
|
||
|
|
}
|
||
|
|
};`;
|
||
|
|
return source;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/multithreading/workers/workers.js
|
||
|
|
var require_workers = __commonJS({
|
||
|
|
"node_modules/neataptic/src/multithreading/workers/workers.js"(exports, module) {
|
||
|
|
var workers = {
|
||
|
|
node: {
|
||
|
|
TestWorker: require_testworker()
|
||
|
|
},
|
||
|
|
browser: {
|
||
|
|
TestWorker: require_testworker2()
|
||
|
|
}
|
||
|
|
};
|
||
|
|
module.exports = workers;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/multithreading/multi.js
|
||
|
|
var require_multi = __commonJS({
|
||
|
|
"node_modules/neataptic/src/multithreading/multi.js"(exports, module) {
|
||
|
|
var multi = {
|
||
|
|
workers: require_workers(),
|
||
|
|
serializeDataSet: function(dataSet) {
|
||
|
|
var serialized = [dataSet[0].input.length, dataSet[0].output.length];
|
||
|
|
for (var i2 = 0; i2 < dataSet.length; i2++) {
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < serialized[0]; j++) {
|
||
|
|
serialized.push(dataSet[i2].input[j]);
|
||
|
|
}
|
||
|
|
for (j = 0; j < serialized[1]; j++) {
|
||
|
|
serialized.push(dataSet[i2].output[j]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return serialized;
|
||
|
|
},
|
||
|
|
activateSerializedNetwork: function(input, A, S, data, F) {
|
||
|
|
for (var i2 = 0; i2 < data[0]; i2++)
|
||
|
|
A[i2] = input[i2];
|
||
|
|
for (i2 = 2; i2 < data.length; i2++) {
|
||
|
|
let index = data[i2++];
|
||
|
|
let bias = data[i2++];
|
||
|
|
let squash = data[i2++];
|
||
|
|
let selfweight = data[i2++];
|
||
|
|
let selfgater = data[i2++];
|
||
|
|
S[index] = (selfgater === -1 ? 1 : A[selfgater]) * selfweight * S[index] + bias;
|
||
|
|
while (data[i2] !== -2) {
|
||
|
|
S[index] += A[data[i2++]] * data[i2++] * (data[i2++] === -1 ? 1 : A[data[i2 - 1]]);
|
||
|
|
}
|
||
|
|
A[index] = F[squash](S[index]);
|
||
|
|
}
|
||
|
|
var output = [];
|
||
|
|
for (i2 = A.length - data[1]; i2 < A.length; i2++)
|
||
|
|
output.push(A[i2]);
|
||
|
|
return output;
|
||
|
|
},
|
||
|
|
deserializeDataSet: function(serializedSet) {
|
||
|
|
var set = [];
|
||
|
|
var sampleSize = serializedSet[0] + serializedSet[1];
|
||
|
|
for (var i2 = 0; i2 < (serializedSet.length - 2) / sampleSize; i2++) {
|
||
|
|
let input = [];
|
||
|
|
for (var j = 2 + i2 * sampleSize; j < 2 + i2 * sampleSize + serializedSet[0]; j++) {
|
||
|
|
input.push(serializedSet[j]);
|
||
|
|
}
|
||
|
|
let output = [];
|
||
|
|
for (j = 2 + i2 * sampleSize + serializedSet[0]; j < 2 + i2 * sampleSize + sampleSize; j++) {
|
||
|
|
output.push(serializedSet[j]);
|
||
|
|
}
|
||
|
|
set.push(input);
|
||
|
|
set.push(output);
|
||
|
|
}
|
||
|
|
return set;
|
||
|
|
},
|
||
|
|
activations: [
|
||
|
|
function(x) {
|
||
|
|
return 1 / (1 + Math.exp(-x));
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return Math.tanh(x);
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return x;
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return x > 0 ? 1 : 0;
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return x > 0 ? x : 0;
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return x / (1 + Math.abs(x));
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return Math.sin(x);
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return Math.exp(-Math.pow(x, 2));
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return (Math.sqrt(Math.pow(x, 2) + 1) - 1) / 2 + x;
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return x > 0 ? 1 : -1;
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return 2 / (1 + Math.exp(-x)) - 1;
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return Math.max(-1, Math.min(1, x));
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return Math.abs(x);
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
return 1 - x;
|
||
|
|
},
|
||
|
|
function(x) {
|
||
|
|
var a = 1.6732632423543772;
|
||
|
|
return (x > 0 ? x : a * Math.exp(x) - a) * 1.0507009873554805;
|
||
|
|
}
|
||
|
|
]
|
||
|
|
};
|
||
|
|
multi.testSerializedSet = function(set, cost, A, S, data, F) {
|
||
|
|
var error = 0;
|
||
|
|
for (var i2 = 0; i2 < set.length; i2 += 2) {
|
||
|
|
let output = multi.activateSerializedNetwork(set[i2], A, S, data, F);
|
||
|
|
error += cost(set[i2 + 1], output);
|
||
|
|
}
|
||
|
|
return error / (set.length / 2);
|
||
|
|
};
|
||
|
|
for (i in multi) {
|
||
|
|
module.exports[i] = multi[i];
|
||
|
|
}
|
||
|
|
var i;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/config.js
|
||
|
|
var require_config = __commonJS({
|
||
|
|
"node_modules/neataptic/src/config.js"(exports, module) {
|
||
|
|
var config = {
|
||
|
|
warnings: false
|
||
|
|
};
|
||
|
|
module.exports = config;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/neat.js
|
||
|
|
var require_neat = __commonJS({
|
||
|
|
"node_modules/neataptic/src/neat.js"(exports, module) {
|
||
|
|
module.exports = Neat;
|
||
|
|
var Network = require_network();
|
||
|
|
var methods = require_methods();
|
||
|
|
var config = require_config();
|
||
|
|
var selection = methods.selection;
|
||
|
|
function Neat(input, output, fitness, options) {
|
||
|
|
this.input = input;
|
||
|
|
this.output = output;
|
||
|
|
this.fitness = fitness;
|
||
|
|
options = options || {};
|
||
|
|
this.equal = options.equal || false;
|
||
|
|
this.clear = options.clear || false;
|
||
|
|
this.popsize = options.popsize || 50;
|
||
|
|
this.elitism = options.elitism || 0;
|
||
|
|
this.provenance = options.provenance || 0;
|
||
|
|
this.mutationRate = options.mutationRate || 0.3;
|
||
|
|
this.mutationAmount = options.mutationAmount || 1;
|
||
|
|
this.fitnessPopulation = options.fitnessPopulation || false;
|
||
|
|
this.selection = options.selection || methods.selection.POWER;
|
||
|
|
this.crossover = options.crossover || [
|
||
|
|
methods.crossover.SINGLE_POINT,
|
||
|
|
methods.crossover.TWO_POINT,
|
||
|
|
methods.crossover.UNIFORM,
|
||
|
|
methods.crossover.AVERAGE
|
||
|
|
];
|
||
|
|
this.mutation = options.mutation || methods.mutation.FFW;
|
||
|
|
this.template = options.network || false;
|
||
|
|
this.maxNodes = options.maxNodes || Infinity;
|
||
|
|
this.maxConns = options.maxConns || Infinity;
|
||
|
|
this.maxGates = options.maxGates || Infinity;
|
||
|
|
this.selectMutationMethod = typeof options.mutationSelection === "function" ? options.mutationSelection.bind(this) : this.selectMutationMethod;
|
||
|
|
this.generation = 0;
|
||
|
|
this.createPool(this.template);
|
||
|
|
}
|
||
|
|
Neat.prototype = {
|
||
|
|
createPool: function(network) {
|
||
|
|
this.population = [];
|
||
|
|
for (var i = 0; i < this.popsize; i++) {
|
||
|
|
var copy;
|
||
|
|
if (this.template) {
|
||
|
|
copy = Network.fromJSON(network.toJSON());
|
||
|
|
} else {
|
||
|
|
copy = new Network(this.input, this.output);
|
||
|
|
}
|
||
|
|
copy.score = void 0;
|
||
|
|
this.population.push(copy);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
evolve: async function() {
|
||
|
|
if (typeof this.population[this.population.length - 1].score === "undefined") {
|
||
|
|
await this.evaluate();
|
||
|
|
}
|
||
|
|
this.sort();
|
||
|
|
var fittest = Network.fromJSON(this.population[0].toJSON());
|
||
|
|
fittest.score = this.population[0].score;
|
||
|
|
var newPopulation = [];
|
||
|
|
var elitists = [];
|
||
|
|
for (var i = 0; i < this.elitism; i++) {
|
||
|
|
elitists.push(this.population[i]);
|
||
|
|
}
|
||
|
|
for (i = 0; i < this.provenance; i++) {
|
||
|
|
newPopulation.push(Network.fromJSON(this.template.toJSON()));
|
||
|
|
}
|
||
|
|
for (i = 0; i < this.popsize - this.elitism - this.provenance; i++) {
|
||
|
|
newPopulation.push(this.getOffspring());
|
||
|
|
}
|
||
|
|
this.population = newPopulation;
|
||
|
|
this.mutate();
|
||
|
|
this.population.push(...elitists);
|
||
|
|
for (i = 0; i < this.population.length; i++) {
|
||
|
|
this.population[i].score = void 0;
|
||
|
|
}
|
||
|
|
this.generation++;
|
||
|
|
return fittest;
|
||
|
|
},
|
||
|
|
getOffspring: function() {
|
||
|
|
var parent1 = this.getParent();
|
||
|
|
var parent2 = this.getParent();
|
||
|
|
return Network.crossOver(parent1, parent2, this.equal);
|
||
|
|
},
|
||
|
|
selectMutationMethod: function(genome) {
|
||
|
|
var mutationMethod = this.mutation[Math.floor(Math.random() * this.mutation.length)];
|
||
|
|
if (mutationMethod === methods.mutation.ADD_NODE && genome.nodes.length >= this.maxNodes) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("maxNodes exceeded!");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (mutationMethod === methods.mutation.ADD_CONN && genome.connections.length >= this.maxConns) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("maxConns exceeded!");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (mutationMethod === methods.mutation.ADD_GATE && genome.gates.length >= this.maxGates) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("maxGates exceeded!");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
return mutationMethod;
|
||
|
|
},
|
||
|
|
mutate: function() {
|
||
|
|
for (var i = 0; i < this.population.length; i++) {
|
||
|
|
if (Math.random() <= this.mutationRate) {
|
||
|
|
for (var j = 0; j < this.mutationAmount; j++) {
|
||
|
|
var mutationMethod = this.selectMutationMethod(this.population[i]);
|
||
|
|
this.population[i].mutate(mutationMethod);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
evaluate: async function() {
|
||
|
|
var i;
|
||
|
|
if (this.fitnessPopulation) {
|
||
|
|
if (this.clear) {
|
||
|
|
for (i = 0; i < this.population.length; i++) {
|
||
|
|
this.population[i].clear();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
await this.fitness(this.population);
|
||
|
|
} else {
|
||
|
|
for (i = 0; i < this.population.length; i++) {
|
||
|
|
var genome = this.population[i];
|
||
|
|
if (this.clear)
|
||
|
|
genome.clear();
|
||
|
|
genome.score = await this.fitness(genome);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
sort: function() {
|
||
|
|
this.population.sort(function(a, b) {
|
||
|
|
return b.score - a.score;
|
||
|
|
});
|
||
|
|
},
|
||
|
|
getFittest: function() {
|
||
|
|
if (typeof this.population[this.population.length - 1].score === "undefined") {
|
||
|
|
this.evaluate();
|
||
|
|
}
|
||
|
|
if (this.population[0].score < this.population[1].score) {
|
||
|
|
this.sort();
|
||
|
|
}
|
||
|
|
return this.population[0];
|
||
|
|
},
|
||
|
|
getAverage: function() {
|
||
|
|
if (typeof this.population[this.population.length - 1].score === "undefined") {
|
||
|
|
this.evaluate();
|
||
|
|
}
|
||
|
|
var score = 0;
|
||
|
|
for (var i = 0; i < this.population.length; i++) {
|
||
|
|
score += this.population[i].score;
|
||
|
|
}
|
||
|
|
return score / this.population.length;
|
||
|
|
},
|
||
|
|
getParent: function() {
|
||
|
|
var i;
|
||
|
|
switch (this.selection) {
|
||
|
|
case selection.POWER:
|
||
|
|
if (this.population[0].score < this.population[1].score)
|
||
|
|
this.sort();
|
||
|
|
var index = Math.floor(Math.pow(Math.random(), this.selection.power) * this.population.length);
|
||
|
|
return this.population[index];
|
||
|
|
case selection.FITNESS_PROPORTIONATE:
|
||
|
|
var totalFitness = 0;
|
||
|
|
var minimalFitness = 0;
|
||
|
|
for (i = 0; i < this.population.length; i++) {
|
||
|
|
var score = this.population[i].score;
|
||
|
|
minimalFitness = score < minimalFitness ? score : minimalFitness;
|
||
|
|
totalFitness += score;
|
||
|
|
}
|
||
|
|
minimalFitness = Math.abs(minimalFitness);
|
||
|
|
totalFitness += minimalFitness * this.population.length;
|
||
|
|
var random = Math.random() * totalFitness;
|
||
|
|
var value = 0;
|
||
|
|
for (i = 0; i < this.population.length; i++) {
|
||
|
|
let genome = this.population[i];
|
||
|
|
value += genome.score + minimalFitness;
|
||
|
|
if (random < value)
|
||
|
|
return genome;
|
||
|
|
}
|
||
|
|
return this.population[Math.floor(Math.random() * this.population.length)];
|
||
|
|
case selection.TOURNAMENT:
|
||
|
|
if (this.selection.size > this.popsize) {
|
||
|
|
throw new Error("Your tournament size should be lower than the population size, please change methods.selection.TOURNAMENT.size");
|
||
|
|
}
|
||
|
|
var individuals = [];
|
||
|
|
for (i = 0; i < this.selection.size; i++) {
|
||
|
|
let random2 = this.population[Math.floor(Math.random() * this.population.length)];
|
||
|
|
individuals.push(random2);
|
||
|
|
}
|
||
|
|
individuals.sort(function(a, b) {
|
||
|
|
return b.score - a.score;
|
||
|
|
});
|
||
|
|
for (i = 0; i < this.selection.size; i++) {
|
||
|
|
if (Math.random() < this.selection.probability || i === this.selection.size - 1) {
|
||
|
|
return individuals[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
export: function() {
|
||
|
|
var json = [];
|
||
|
|
for (var i = 0; i < this.population.length; i++) {
|
||
|
|
var genome = this.population[i];
|
||
|
|
json.push(genome.toJSON());
|
||
|
|
}
|
||
|
|
return json;
|
||
|
|
},
|
||
|
|
import: function(json) {
|
||
|
|
var population = [];
|
||
|
|
for (var i = 0; i < json.length; i++) {
|
||
|
|
var genome = json[i];
|
||
|
|
population.push(Network.fromJSON(genome));
|
||
|
|
}
|
||
|
|
this.population = population;
|
||
|
|
this.popsize = population.length;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/architecture/node.js
|
||
|
|
var require_node = __commonJS({
|
||
|
|
"node_modules/neataptic/src/architecture/node.js"(exports, module) {
|
||
|
|
module.exports = Node;
|
||
|
|
var methods = require_methods();
|
||
|
|
var Connection = require_connection2();
|
||
|
|
var config = require_config();
|
||
|
|
function Node(type) {
|
||
|
|
this.bias = type === "input" ? 0 : Math.random() * 0.2 - 0.1;
|
||
|
|
this.squash = methods.activation.LOGISTIC;
|
||
|
|
this.type = type || "hidden";
|
||
|
|
this.activation = 0;
|
||
|
|
this.state = 0;
|
||
|
|
this.old = 0;
|
||
|
|
this.mask = 1;
|
||
|
|
this.previousDeltaBias = 0;
|
||
|
|
this.totalDeltaBias = 0;
|
||
|
|
this.connections = {
|
||
|
|
in: [],
|
||
|
|
out: [],
|
||
|
|
gated: [],
|
||
|
|
self: new Connection(this, this, 0)
|
||
|
|
};
|
||
|
|
this.error = {
|
||
|
|
responsibility: 0,
|
||
|
|
projected: 0,
|
||
|
|
gated: 0
|
||
|
|
};
|
||
|
|
}
|
||
|
|
Node.prototype = {
|
||
|
|
activate: function(input) {
|
||
|
|
if (typeof input !== "undefined") {
|
||
|
|
this.activation = input;
|
||
|
|
return this.activation;
|
||
|
|
}
|
||
|
|
this.old = this.state;
|
||
|
|
this.state = this.connections.self.gain * this.connections.self.weight * this.state + this.bias;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < this.connections.in.length; i++) {
|
||
|
|
var connection = this.connections.in[i];
|
||
|
|
this.state += connection.from.activation * connection.weight * connection.gain;
|
||
|
|
}
|
||
|
|
this.activation = this.squash(this.state) * this.mask;
|
||
|
|
this.derivative = this.squash(this.state, true);
|
||
|
|
var nodes = [];
|
||
|
|
var influences = [];
|
||
|
|
for (i = 0; i < this.connections.gated.length; i++) {
|
||
|
|
let conn = this.connections.gated[i];
|
||
|
|
let node = conn.to;
|
||
|
|
let index = nodes.indexOf(node);
|
||
|
|
if (index > -1) {
|
||
|
|
influences[index] += conn.weight * conn.from.activation;
|
||
|
|
} else {
|
||
|
|
nodes.push(node);
|
||
|
|
influences.push(conn.weight * conn.from.activation + (node.connections.self.gater === this ? node.old : 0));
|
||
|
|
}
|
||
|
|
conn.gain = this.activation;
|
||
|
|
}
|
||
|
|
for (i = 0; i < this.connections.in.length; i++) {
|
||
|
|
let connection2 = this.connections.in[i];
|
||
|
|
connection2.elegibility = this.connections.self.gain * this.connections.self.weight * connection2.elegibility + connection2.from.activation * connection2.gain;
|
||
|
|
for (var j = 0; j < nodes.length; j++) {
|
||
|
|
let node = nodes[j];
|
||
|
|
let influence = influences[j];
|
||
|
|
let index = connection2.xtrace.nodes.indexOf(node);
|
||
|
|
if (index > -1) {
|
||
|
|
connection2.xtrace.values[index] = node.connections.self.gain * node.connections.self.weight * connection2.xtrace.values[index] + this.derivative * connection2.elegibility * influence;
|
||
|
|
} else {
|
||
|
|
connection2.xtrace.nodes.push(node);
|
||
|
|
connection2.xtrace.values.push(this.derivative * connection2.elegibility * influence);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return this.activation;
|
||
|
|
},
|
||
|
|
noTraceActivate: function(input) {
|
||
|
|
if (typeof input !== "undefined") {
|
||
|
|
this.activation = input;
|
||
|
|
return this.activation;
|
||
|
|
}
|
||
|
|
this.state = this.connections.self.gain * this.connections.self.weight * this.state + this.bias;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < this.connections.in.length; i++) {
|
||
|
|
var connection = this.connections.in[i];
|
||
|
|
this.state += connection.from.activation * connection.weight * connection.gain;
|
||
|
|
}
|
||
|
|
this.activation = this.squash(this.state);
|
||
|
|
for (i = 0; i < this.connections.gated.length; i++) {
|
||
|
|
this.connections.gated[i].gain = this.activation;
|
||
|
|
}
|
||
|
|
return this.activation;
|
||
|
|
},
|
||
|
|
propagate: function(rate, momentum, update, target) {
|
||
|
|
momentum = momentum || 0;
|
||
|
|
rate = rate || 0.3;
|
||
|
|
var error = 0;
|
||
|
|
if (this.type === "output") {
|
||
|
|
this.error.responsibility = this.error.projected = target - this.activation;
|
||
|
|
} else {
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < this.connections.out.length; i++) {
|
||
|
|
let connection = this.connections.out[i];
|
||
|
|
let node = connection.to;
|
||
|
|
error += node.error.responsibility * connection.weight * connection.gain;
|
||
|
|
}
|
||
|
|
this.error.projected = this.derivative * error;
|
||
|
|
error = 0;
|
||
|
|
for (i = 0; i < this.connections.gated.length; i++) {
|
||
|
|
let conn = this.connections.gated[i];
|
||
|
|
let node = conn.to;
|
||
|
|
let influence = node.connections.self.gater === this ? node.old : 0;
|
||
|
|
influence += conn.weight * conn.from.activation;
|
||
|
|
error += node.error.responsibility * influence;
|
||
|
|
}
|
||
|
|
this.error.gated = this.derivative * error;
|
||
|
|
this.error.responsibility = this.error.projected + this.error.gated;
|
||
|
|
}
|
||
|
|
if (this.type === "constant")
|
||
|
|
return;
|
||
|
|
for (i = 0; i < this.connections.in.length; i++) {
|
||
|
|
let connection = this.connections.in[i];
|
||
|
|
let gradient = this.error.projected * connection.elegibility;
|
||
|
|
for (var j = 0; j < connection.xtrace.nodes.length; j++) {
|
||
|
|
let node = connection.xtrace.nodes[j];
|
||
|
|
let value = connection.xtrace.values[j];
|
||
|
|
gradient += node.error.responsibility * value;
|
||
|
|
}
|
||
|
|
let deltaWeight = rate * gradient * this.mask;
|
||
|
|
connection.totalDeltaWeight += deltaWeight;
|
||
|
|
if (update) {
|
||
|
|
connection.totalDeltaWeight += momentum * connection.previousDeltaWeight;
|
||
|
|
connection.weight += connection.totalDeltaWeight;
|
||
|
|
connection.previousDeltaWeight = connection.totalDeltaWeight;
|
||
|
|
connection.totalDeltaWeight = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var deltaBias = rate * this.error.responsibility;
|
||
|
|
this.totalDeltaBias += deltaBias;
|
||
|
|
if (update) {
|
||
|
|
this.totalDeltaBias += momentum * this.previousDeltaBias;
|
||
|
|
this.bias += this.totalDeltaBias;
|
||
|
|
this.previousDeltaBias = this.totalDeltaBias;
|
||
|
|
this.totalDeltaBias = 0;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
connect: function(target, weight) {
|
||
|
|
var connections = [];
|
||
|
|
if (typeof target.bias !== "undefined") {
|
||
|
|
if (target === this) {
|
||
|
|
if (this.connections.self.weight !== 0) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("This connection already exists!");
|
||
|
|
} else {
|
||
|
|
this.connections.self.weight = weight || 1;
|
||
|
|
}
|
||
|
|
connections.push(this.connections.self);
|
||
|
|
} else if (this.isProjectingTo(target)) {
|
||
|
|
throw new Error("Already projecting a connection to this node!");
|
||
|
|
} else {
|
||
|
|
let connection = new Connection(this, target, weight);
|
||
|
|
target.connections.in.push(connection);
|
||
|
|
this.connections.out.push(connection);
|
||
|
|
connections.push(connection);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (var i = 0; i < target.nodes.length; i++) {
|
||
|
|
let connection = new Connection(this, target.nodes[i], weight);
|
||
|
|
target.nodes[i].connections.in.push(connection);
|
||
|
|
this.connections.out.push(connection);
|
||
|
|
target.connections.in.push(connection);
|
||
|
|
connections.push(connection);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return connections;
|
||
|
|
},
|
||
|
|
disconnect: function(node, twosided) {
|
||
|
|
if (this === node) {
|
||
|
|
this.connections.self.weight = 0;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
for (var i = 0; i < this.connections.out.length; i++) {
|
||
|
|
let conn = this.connections.out[i];
|
||
|
|
if (conn.to === node) {
|
||
|
|
this.connections.out.splice(i, 1);
|
||
|
|
let j = conn.to.connections.in.indexOf(conn);
|
||
|
|
conn.to.connections.in.splice(j, 1);
|
||
|
|
if (conn.gater !== null)
|
||
|
|
conn.gater.ungate(conn);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (twosided) {
|
||
|
|
node.disconnect(this);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
gate: function(connections) {
|
||
|
|
if (!Array.isArray(connections)) {
|
||
|
|
connections = [connections];
|
||
|
|
}
|
||
|
|
for (var i = 0; i < connections.length; i++) {
|
||
|
|
var connection = connections[i];
|
||
|
|
this.connections.gated.push(connection);
|
||
|
|
connection.gater = this;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
ungate: function(connections) {
|
||
|
|
if (!Array.isArray(connections)) {
|
||
|
|
connections = [connections];
|
||
|
|
}
|
||
|
|
for (var i = connections.length - 1; i >= 0; i--) {
|
||
|
|
var connection = connections[i];
|
||
|
|
var index = this.connections.gated.indexOf(connection);
|
||
|
|
this.connections.gated.splice(index, 1);
|
||
|
|
connection.gater = null;
|
||
|
|
connection.gain = 1;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
clear: function() {
|
||
|
|
for (var i = 0; i < this.connections.in.length; i++) {
|
||
|
|
var connection = this.connections.in[i];
|
||
|
|
connection.elegibility = 0;
|
||
|
|
connection.xtrace = {
|
||
|
|
nodes: [],
|
||
|
|
values: []
|
||
|
|
};
|
||
|
|
}
|
||
|
|
for (i = 0; i < this.connections.gated.length; i++) {
|
||
|
|
let conn = this.connections.gated[i];
|
||
|
|
conn.gain = 0;
|
||
|
|
}
|
||
|
|
this.error.responsibility = this.error.projected = this.error.gated = 0;
|
||
|
|
this.old = this.state = this.activation = 0;
|
||
|
|
},
|
||
|
|
mutate: function(method) {
|
||
|
|
if (typeof method === "undefined") {
|
||
|
|
throw new Error("No mutate method given!");
|
||
|
|
} else if (!(method.name in methods.mutation)) {
|
||
|
|
throw new Error("This method does not exist!");
|
||
|
|
}
|
||
|
|
switch (method) {
|
||
|
|
case methods.mutation.MOD_ACTIVATION:
|
||
|
|
var squash = method.allowed[(method.allowed.indexOf(this.squash) + Math.floor(Math.random() * (method.allowed.length - 1)) + 1) % method.allowed.length];
|
||
|
|
this.squash = squash;
|
||
|
|
break;
|
||
|
|
case methods.mutation.MOD_BIAS:
|
||
|
|
var modification = Math.random() * (method.max - method.min) + method.min;
|
||
|
|
this.bias += modification;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
isProjectingTo: function(node) {
|
||
|
|
if (node === this && this.connections.self.weight !== 0)
|
||
|
|
return true;
|
||
|
|
for (var i = 0; i < this.connections.out.length; i++) {
|
||
|
|
var conn = this.connections.out[i];
|
||
|
|
if (conn.to === node) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
},
|
||
|
|
isProjectedBy: function(node) {
|
||
|
|
if (node === this && this.connections.self.weight !== 0)
|
||
|
|
return true;
|
||
|
|
for (var i = 0; i < this.connections.in.length; i++) {
|
||
|
|
var conn = this.connections.in[i];
|
||
|
|
if (conn.from === node) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
},
|
||
|
|
toJSON: function() {
|
||
|
|
var json = {
|
||
|
|
bias: this.bias,
|
||
|
|
type: this.type,
|
||
|
|
squash: this.squash.name,
|
||
|
|
mask: this.mask
|
||
|
|
};
|
||
|
|
return json;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Node.fromJSON = function(json) {
|
||
|
|
var node = new Node();
|
||
|
|
node.bias = json.bias;
|
||
|
|
node.type = json.type;
|
||
|
|
node.mask = json.mask;
|
||
|
|
node.squash = methods.activation[json.squash];
|
||
|
|
return node;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// browser-external:os
|
||
|
|
var os_exports = {};
|
||
|
|
__export(os_exports, {
|
||
|
|
default: () => os_default
|
||
|
|
});
|
||
|
|
var os_default;
|
||
|
|
var init_os = __esm({
|
||
|
|
"browser-external:os"() {
|
||
|
|
os_default = new Proxy({}, {
|
||
|
|
get() {
|
||
|
|
throw new Error('Module "os" has been externalized for browser compatibility and cannot be accessed in client code.');
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/architecture/network.js
|
||
|
|
var require_network = __commonJS({
|
||
|
|
"node_modules/neataptic/src/architecture/network.js"(exports, module) {
|
||
|
|
module.exports = Network;
|
||
|
|
var multi = require_multi();
|
||
|
|
var methods = require_methods();
|
||
|
|
var Connection = require_connection2();
|
||
|
|
var config = require_config();
|
||
|
|
var Neat = require_neat();
|
||
|
|
var Node = require_node();
|
||
|
|
var mutation = methods.mutation;
|
||
|
|
function Network(input, output) {
|
||
|
|
if (typeof input === "undefined" || typeof output === "undefined") {
|
||
|
|
throw new Error("No input or output size given");
|
||
|
|
}
|
||
|
|
this.input = input;
|
||
|
|
this.output = output;
|
||
|
|
this.nodes = [];
|
||
|
|
this.connections = [];
|
||
|
|
this.gates = [];
|
||
|
|
this.selfconns = [];
|
||
|
|
this.dropout = 0;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < this.input + this.output; i++) {
|
||
|
|
var type = i < this.input ? "input" : "output";
|
||
|
|
this.nodes.push(new Node(type));
|
||
|
|
}
|
||
|
|
for (i = 0; i < this.input; i++) {
|
||
|
|
for (var j = this.input; j < this.output + this.input; j++) {
|
||
|
|
var weight = Math.random() * this.input * Math.sqrt(2 / this.input);
|
||
|
|
this.connect(this.nodes[i], this.nodes[j], weight);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Network.prototype = {
|
||
|
|
activate: function(input, training) {
|
||
|
|
var output = [];
|
||
|
|
for (var i = 0; i < this.nodes.length; i++) {
|
||
|
|
if (this.nodes[i].type === "input") {
|
||
|
|
this.nodes[i].activate(input[i]);
|
||
|
|
} else if (this.nodes[i].type === "output") {
|
||
|
|
var activation = this.nodes[i].activate();
|
||
|
|
output.push(activation);
|
||
|
|
} else {
|
||
|
|
if (training)
|
||
|
|
this.nodes[i].mask = Math.random() < this.dropout ? 0 : 1;
|
||
|
|
this.nodes[i].activate();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return output;
|
||
|
|
},
|
||
|
|
noTraceActivate: function(input) {
|
||
|
|
var output = [];
|
||
|
|
for (var i = 0; i < this.nodes.length; i++) {
|
||
|
|
if (this.nodes[i].type === "input") {
|
||
|
|
this.nodes[i].noTraceActivate(input[i]);
|
||
|
|
} else if (this.nodes[i].type === "output") {
|
||
|
|
var activation = this.nodes[i].noTraceActivate();
|
||
|
|
output.push(activation);
|
||
|
|
} else {
|
||
|
|
this.nodes[i].noTraceActivate();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return output;
|
||
|
|
},
|
||
|
|
propagate: function(rate, momentum, update, target) {
|
||
|
|
if (typeof target === "undefined" || target.length !== this.output) {
|
||
|
|
throw new Error("Output target length should match network output length");
|
||
|
|
}
|
||
|
|
var targetIndex = target.length;
|
||
|
|
var i;
|
||
|
|
for (i = this.nodes.length - 1; i >= this.nodes.length - this.output; i--) {
|
||
|
|
this.nodes[i].propagate(rate, momentum, update, target[--targetIndex]);
|
||
|
|
}
|
||
|
|
for (i = this.nodes.length - this.output - 1; i >= this.input; i--) {
|
||
|
|
this.nodes[i].propagate(rate, momentum, update);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
clear: function() {
|
||
|
|
for (var i = 0; i < this.nodes.length; i++) {
|
||
|
|
this.nodes[i].clear();
|
||
|
|
}
|
||
|
|
},
|
||
|
|
connect: function(from, to, weight) {
|
||
|
|
var connections = from.connect(to, weight);
|
||
|
|
for (var i = 0; i < connections.length; i++) {
|
||
|
|
var connection = connections[i];
|
||
|
|
if (from !== to) {
|
||
|
|
this.connections.push(connection);
|
||
|
|
} else {
|
||
|
|
this.selfconns.push(connection);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return connections;
|
||
|
|
},
|
||
|
|
disconnect: function(from, to) {
|
||
|
|
var connections = from === to ? this.selfconns : this.connections;
|
||
|
|
for (var i = 0; i < connections.length; i++) {
|
||
|
|
var connection = connections[i];
|
||
|
|
if (connection.from === from && connection.to === to) {
|
||
|
|
if (connection.gater !== null)
|
||
|
|
this.ungate(connection);
|
||
|
|
connections.splice(i, 1);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
from.disconnect(to);
|
||
|
|
},
|
||
|
|
gate: function(node, connection) {
|
||
|
|
if (this.nodes.indexOf(node) === -1) {
|
||
|
|
throw new Error("This node is not part of the network!");
|
||
|
|
} else if (connection.gater != null) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("This connection is already gated!");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
node.gate(connection);
|
||
|
|
this.gates.push(connection);
|
||
|
|
},
|
||
|
|
ungate: function(connection) {
|
||
|
|
var index = this.gates.indexOf(connection);
|
||
|
|
if (index === -1) {
|
||
|
|
throw new Error("This connection is not gated!");
|
||
|
|
}
|
||
|
|
this.gates.splice(index, 1);
|
||
|
|
connection.gater.ungate(connection);
|
||
|
|
},
|
||
|
|
remove: function(node) {
|
||
|
|
var index = this.nodes.indexOf(node);
|
||
|
|
if (index === -1) {
|
||
|
|
throw new Error("This node does not exist in the network!");
|
||
|
|
}
|
||
|
|
var gaters = [];
|
||
|
|
this.disconnect(node, node);
|
||
|
|
var inputs = [];
|
||
|
|
for (var i = node.connections.in.length - 1; i >= 0; i--) {
|
||
|
|
let connection = node.connections.in[i];
|
||
|
|
if (mutation.SUB_NODE.keep_gates && connection.gater !== null && connection.gater !== node) {
|
||
|
|
gaters.push(connection.gater);
|
||
|
|
}
|
||
|
|
inputs.push(connection.from);
|
||
|
|
this.disconnect(connection.from, node);
|
||
|
|
}
|
||
|
|
var outputs = [];
|
||
|
|
for (i = node.connections.out.length - 1; i >= 0; i--) {
|
||
|
|
let connection = node.connections.out[i];
|
||
|
|
if (mutation.SUB_NODE.keep_gates && connection.gater !== null && connection.gater !== node) {
|
||
|
|
gaters.push(connection.gater);
|
||
|
|
}
|
||
|
|
outputs.push(connection.to);
|
||
|
|
this.disconnect(node, connection.to);
|
||
|
|
}
|
||
|
|
var connections = [];
|
||
|
|
for (i = 0; i < inputs.length; i++) {
|
||
|
|
let input = inputs[i];
|
||
|
|
for (var j = 0; j < outputs.length; j++) {
|
||
|
|
let output = outputs[j];
|
||
|
|
if (!input.isProjectingTo(output)) {
|
||
|
|
var conn = this.connect(input, output);
|
||
|
|
connections.push(conn[0]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (i = 0; i < gaters.length; i++) {
|
||
|
|
if (connections.length === 0)
|
||
|
|
break;
|
||
|
|
let gater = gaters[i];
|
||
|
|
let connIndex = Math.floor(Math.random() * connections.length);
|
||
|
|
this.gate(gater, connections[connIndex]);
|
||
|
|
connections.splice(connIndex, 1);
|
||
|
|
}
|
||
|
|
for (i = node.connections.gated.length - 1; i >= 0; i--) {
|
||
|
|
let conn2 = node.connections.gated[i];
|
||
|
|
this.ungate(conn2);
|
||
|
|
}
|
||
|
|
this.disconnect(node, node);
|
||
|
|
this.nodes.splice(index, 1);
|
||
|
|
},
|
||
|
|
mutate: function(method) {
|
||
|
|
if (typeof method === "undefined") {
|
||
|
|
throw new Error("No (correct) mutate method given!");
|
||
|
|
}
|
||
|
|
var i, j;
|
||
|
|
switch (method) {
|
||
|
|
case mutation.ADD_NODE:
|
||
|
|
var connection = this.connections[Math.floor(Math.random() * this.connections.length)];
|
||
|
|
var gater = connection.gater;
|
||
|
|
this.disconnect(connection.from, connection.to);
|
||
|
|
var toIndex = this.nodes.indexOf(connection.to);
|
||
|
|
var node = new Node("hidden");
|
||
|
|
node.mutate(mutation.MOD_ACTIVATION);
|
||
|
|
var minBound = Math.min(toIndex, this.nodes.length - this.output);
|
||
|
|
this.nodes.splice(minBound, 0, node);
|
||
|
|
var newConn1 = this.connect(connection.from, node)[0];
|
||
|
|
var newConn2 = this.connect(node, connection.to)[0];
|
||
|
|
if (gater != null) {
|
||
|
|
this.gate(gater, Math.random() >= 0.5 ? newConn1 : newConn2);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case mutation.SUB_NODE:
|
||
|
|
if (this.nodes.length === this.input + this.output) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No more nodes left to remove!");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var index = Math.floor(Math.random() * (this.nodes.length - this.output - this.input) + this.input);
|
||
|
|
this.remove(this.nodes[index]);
|
||
|
|
break;
|
||
|
|
case mutation.ADD_CONN:
|
||
|
|
var available = [];
|
||
|
|
for (i = 0; i < this.nodes.length - this.output; i++) {
|
||
|
|
let node12 = this.nodes[i];
|
||
|
|
for (j = Math.max(i + 1, this.input); j < this.nodes.length; j++) {
|
||
|
|
let node22 = this.nodes[j];
|
||
|
|
if (!node12.isProjectingTo(node22))
|
||
|
|
available.push([node12, node22]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (available.length === 0) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No more connections to be made!");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var pair = available[Math.floor(Math.random() * available.length)];
|
||
|
|
this.connect(pair[0], pair[1]);
|
||
|
|
break;
|
||
|
|
case mutation.SUB_CONN:
|
||
|
|
var possible = [];
|
||
|
|
for (i = 0; i < this.connections.length; i++) {
|
||
|
|
let conn2 = this.connections[i];
|
||
|
|
if (conn2.from.connections.out.length > 1 && conn2.to.connections.in.length > 1 && this.nodes.indexOf(conn2.to) > this.nodes.indexOf(conn2.from)) {
|
||
|
|
possible.push(conn2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (possible.length === 0) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No connections to remove!");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var randomConn = possible[Math.floor(Math.random() * possible.length)];
|
||
|
|
this.disconnect(randomConn.from, randomConn.to);
|
||
|
|
break;
|
||
|
|
case mutation.MOD_WEIGHT:
|
||
|
|
var allconnections = this.connections.concat(this.selfconns);
|
||
|
|
var connection = allconnections[Math.floor(Math.random() * allconnections.length)];
|
||
|
|
var modification = Math.random() * (method.max - method.min) + method.min;
|
||
|
|
connection.weight += modification;
|
||
|
|
break;
|
||
|
|
case mutation.MOD_BIAS:
|
||
|
|
var index = Math.floor(Math.random() * (this.nodes.length - this.input) + this.input);
|
||
|
|
var node = this.nodes[index];
|
||
|
|
node.mutate(method);
|
||
|
|
break;
|
||
|
|
case mutation.MOD_ACTIVATION:
|
||
|
|
if (!method.mutateOutput && this.input + this.output === this.nodes.length) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No nodes that allow mutation of activation function");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var index = Math.floor(Math.random() * (this.nodes.length - (method.mutateOutput ? 0 : this.output) - this.input) + this.input);
|
||
|
|
var node = this.nodes[index];
|
||
|
|
node.mutate(method);
|
||
|
|
break;
|
||
|
|
case mutation.ADD_SELF_CONN:
|
||
|
|
var possible = [];
|
||
|
|
for (i = this.input; i < this.nodes.length; i++) {
|
||
|
|
let node3 = this.nodes[i];
|
||
|
|
if (node3.connections.self.weight === 0) {
|
||
|
|
possible.push(node3);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (possible.length === 0) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No more self-connections to add!");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var node = possible[Math.floor(Math.random() * possible.length)];
|
||
|
|
this.connect(node, node);
|
||
|
|
break;
|
||
|
|
case mutation.SUB_SELF_CONN:
|
||
|
|
if (this.selfconns.length === 0) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No more self-connections to remove!");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var conn = this.selfconns[Math.floor(Math.random() * this.selfconns.length)];
|
||
|
|
this.disconnect(conn.from, conn.to);
|
||
|
|
break;
|
||
|
|
case mutation.ADD_GATE:
|
||
|
|
var allconnections = this.connections.concat(this.selfconns);
|
||
|
|
var possible = [];
|
||
|
|
for (i = 0; i < allconnections.length; i++) {
|
||
|
|
let conn2 = allconnections[i];
|
||
|
|
if (conn2.gater === null) {
|
||
|
|
possible.push(conn2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (possible.length === 0) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No more connections to gate!");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var index = Math.floor(Math.random() * (this.nodes.length - this.input) + this.input);
|
||
|
|
var node = this.nodes[index];
|
||
|
|
var conn = possible[Math.floor(Math.random() * possible.length)];
|
||
|
|
this.gate(node, conn);
|
||
|
|
break;
|
||
|
|
case mutation.SUB_GATE:
|
||
|
|
if (this.gates.length === 0) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No more connections to ungate!");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var index = Math.floor(Math.random() * this.gates.length);
|
||
|
|
var gatedconn = this.gates[index];
|
||
|
|
this.ungate(gatedconn);
|
||
|
|
break;
|
||
|
|
case mutation.ADD_BACK_CONN:
|
||
|
|
var available = [];
|
||
|
|
for (i = this.input; i < this.nodes.length; i++) {
|
||
|
|
let node12 = this.nodes[i];
|
||
|
|
for (j = this.input; j < i; j++) {
|
||
|
|
let node22 = this.nodes[j];
|
||
|
|
if (!node12.isProjectingTo(node22))
|
||
|
|
available.push([node12, node22]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (available.length === 0) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No more connections to be made!");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var pair = available[Math.floor(Math.random() * available.length)];
|
||
|
|
this.connect(pair[0], pair[1]);
|
||
|
|
break;
|
||
|
|
case mutation.SUB_BACK_CONN:
|
||
|
|
var possible = [];
|
||
|
|
for (i = 0; i < this.connections.length; i++) {
|
||
|
|
let conn2 = this.connections[i];
|
||
|
|
if (conn2.from.connections.out.length > 1 && conn2.to.connections.in.length > 1 && this.nodes.indexOf(conn2.from) > this.nodes.indexOf(conn2.to)) {
|
||
|
|
possible.push(conn2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (possible.length === 0) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No connections to remove!");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var randomConn = possible[Math.floor(Math.random() * possible.length)];
|
||
|
|
this.disconnect(randomConn.from, randomConn.to);
|
||
|
|
break;
|
||
|
|
case mutation.SWAP_NODES:
|
||
|
|
if (method.mutateOutput && this.nodes.length - this.input < 2 || !method.mutateOutput && this.nodes.length - this.input - this.output < 2) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No nodes that allow swapping of bias and activation function");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var index = Math.floor(Math.random() * (this.nodes.length - (method.mutateOutput ? 0 : this.output) - this.input) + this.input);
|
||
|
|
var node1 = this.nodes[index];
|
||
|
|
index = Math.floor(Math.random() * (this.nodes.length - (method.mutateOutput ? 0 : this.output) - this.input) + this.input);
|
||
|
|
var node2 = this.nodes[index];
|
||
|
|
var biasTemp = node1.bias;
|
||
|
|
var squashTemp = node1.squash;
|
||
|
|
node1.bias = node2.bias;
|
||
|
|
node1.squash = node2.squash;
|
||
|
|
node2.bias = biasTemp;
|
||
|
|
node2.squash = squashTemp;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
train: function(set, options) {
|
||
|
|
if (set[0].input.length !== this.input || set[0].output.length !== this.output) {
|
||
|
|
throw new Error("Dataset input/output size should be same as network input/output size!");
|
||
|
|
}
|
||
|
|
options = options || {};
|
||
|
|
if (typeof options.rate === "undefined") {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("Using default learning rate, please define a rate!");
|
||
|
|
}
|
||
|
|
if (typeof options.iterations === "undefined") {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No target iterations given, running until error is reached!");
|
||
|
|
}
|
||
|
|
var targetError = options.error || 0.05;
|
||
|
|
var cost = options.cost || methods.cost.MSE;
|
||
|
|
var baseRate = options.rate || 0.3;
|
||
|
|
var dropout = options.dropout || 0;
|
||
|
|
var momentum = options.momentum || 0;
|
||
|
|
var batchSize = options.batchSize || 1;
|
||
|
|
var ratePolicy = options.ratePolicy || methods.rate.FIXED();
|
||
|
|
var start = Date.now();
|
||
|
|
if (batchSize > set.length) {
|
||
|
|
throw new Error("Batch size must be smaller or equal to dataset length!");
|
||
|
|
} else if (typeof options.iterations === "undefined" && typeof options.error === "undefined") {
|
||
|
|
throw new Error("At least one of the following options must be specified: error, iterations");
|
||
|
|
} else if (typeof options.error === "undefined") {
|
||
|
|
targetError = -1;
|
||
|
|
} else if (typeof options.iterations === "undefined") {
|
||
|
|
options.iterations = 0;
|
||
|
|
}
|
||
|
|
this.dropout = dropout;
|
||
|
|
if (options.crossValidate) {
|
||
|
|
let numTrain = Math.ceil((1 - options.crossValidate.testSize) * set.length);
|
||
|
|
var trainSet = set.slice(0, numTrain);
|
||
|
|
var testSet = set.slice(numTrain);
|
||
|
|
}
|
||
|
|
var currentRate = baseRate;
|
||
|
|
var iteration = 0;
|
||
|
|
var error = 1;
|
||
|
|
var i, j, x;
|
||
|
|
while (error > targetError && (options.iterations === 0 || iteration < options.iterations)) {
|
||
|
|
if (options.crossValidate && error <= options.crossValidate.testError)
|
||
|
|
break;
|
||
|
|
iteration++;
|
||
|
|
currentRate = ratePolicy(baseRate, iteration);
|
||
|
|
if (options.crossValidate) {
|
||
|
|
this._trainSet(trainSet, batchSize, currentRate, momentum, cost);
|
||
|
|
if (options.clear)
|
||
|
|
this.clear();
|
||
|
|
error = this.test(testSet, cost).error;
|
||
|
|
if (options.clear)
|
||
|
|
this.clear();
|
||
|
|
} else {
|
||
|
|
error = this._trainSet(set, batchSize, currentRate, momentum, cost);
|
||
|
|
if (options.clear)
|
||
|
|
this.clear();
|
||
|
|
}
|
||
|
|
if (options.shuffle) {
|
||
|
|
for (j, x, i = set.length; i; j = Math.floor(Math.random() * i), x = set[--i], set[i] = set[j], set[j] = x)
|
||
|
|
;
|
||
|
|
}
|
||
|
|
if (options.log && iteration % options.log === 0) {
|
||
|
|
console.log("iteration", iteration, "error", error, "rate", currentRate);
|
||
|
|
}
|
||
|
|
if (options.schedule && iteration % options.schedule.iterations === 0) {
|
||
|
|
options.schedule.function({ error, iteration });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (options.clear)
|
||
|
|
this.clear();
|
||
|
|
if (dropout) {
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
if (this.nodes[i].type === "hidden" || this.nodes[i].type === "constant") {
|
||
|
|
this.nodes[i].mask = 1 - this.dropout;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return {
|
||
|
|
error,
|
||
|
|
iterations: iteration,
|
||
|
|
time: Date.now() - start
|
||
|
|
};
|
||
|
|
},
|
||
|
|
_trainSet: function(set, batchSize, currentRate, momentum, costFunction) {
|
||
|
|
var errorSum = 0;
|
||
|
|
for (var i = 0; i < set.length; i++) {
|
||
|
|
var input = set[i].input;
|
||
|
|
var target = set[i].output;
|
||
|
|
var update = !!((i + 1) % batchSize === 0 || i + 1 === set.length);
|
||
|
|
var output = this.activate(input, true);
|
||
|
|
this.propagate(currentRate, momentum, update, target);
|
||
|
|
errorSum += costFunction(target, output);
|
||
|
|
}
|
||
|
|
return errorSum / set.length;
|
||
|
|
},
|
||
|
|
test: function(set, cost = methods.cost.MSE) {
|
||
|
|
var i;
|
||
|
|
if (this.dropout) {
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
if (this.nodes[i].type === "hidden" || this.nodes[i].type === "constant") {
|
||
|
|
this.nodes[i].mask = 1 - this.dropout;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var error = 0;
|
||
|
|
var start = Date.now();
|
||
|
|
for (i = 0; i < set.length; i++) {
|
||
|
|
let input = set[i].input;
|
||
|
|
let target = set[i].output;
|
||
|
|
let output = this.noTraceActivate(input);
|
||
|
|
error += cost(target, output);
|
||
|
|
}
|
||
|
|
error /= set.length;
|
||
|
|
var results = {
|
||
|
|
error,
|
||
|
|
time: Date.now() - start
|
||
|
|
};
|
||
|
|
return results;
|
||
|
|
},
|
||
|
|
graph: function(width, height) {
|
||
|
|
var input = 0;
|
||
|
|
var output = 0;
|
||
|
|
var json = {
|
||
|
|
nodes: [],
|
||
|
|
links: [],
|
||
|
|
constraints: [{
|
||
|
|
type: "alignment",
|
||
|
|
axis: "x",
|
||
|
|
offsets: []
|
||
|
|
}, {
|
||
|
|
type: "alignment",
|
||
|
|
axis: "y",
|
||
|
|
offsets: []
|
||
|
|
}]
|
||
|
|
};
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
var node = this.nodes[i];
|
||
|
|
if (node.type === "input") {
|
||
|
|
if (this.input === 1) {
|
||
|
|
json.constraints[0].offsets.push({
|
||
|
|
node: i,
|
||
|
|
offset: 0
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
json.constraints[0].offsets.push({
|
||
|
|
node: i,
|
||
|
|
offset: 0.8 * width / (this.input - 1) * input++
|
||
|
|
});
|
||
|
|
}
|
||
|
|
json.constraints[1].offsets.push({
|
||
|
|
node: i,
|
||
|
|
offset: 0
|
||
|
|
});
|
||
|
|
} else if (node.type === "output") {
|
||
|
|
if (this.output === 1) {
|
||
|
|
json.constraints[0].offsets.push({
|
||
|
|
node: i,
|
||
|
|
offset: 0
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
json.constraints[0].offsets.push({
|
||
|
|
node: i,
|
||
|
|
offset: 0.8 * width / (this.output - 1) * output++
|
||
|
|
});
|
||
|
|
}
|
||
|
|
json.constraints[1].offsets.push({
|
||
|
|
node: i,
|
||
|
|
offset: -0.8 * height
|
||
|
|
});
|
||
|
|
}
|
||
|
|
json.nodes.push({
|
||
|
|
id: i,
|
||
|
|
name: node.type === "hidden" ? node.squash.name : node.type.toUpperCase(),
|
||
|
|
activation: node.activation,
|
||
|
|
bias: node.bias
|
||
|
|
});
|
||
|
|
}
|
||
|
|
var connections = this.connections.concat(this.selfconns);
|
||
|
|
for (i = 0; i < connections.length; i++) {
|
||
|
|
var connection = connections[i];
|
||
|
|
if (connection.gater == null) {
|
||
|
|
json.links.push({
|
||
|
|
source: this.nodes.indexOf(connection.from),
|
||
|
|
target: this.nodes.indexOf(connection.to),
|
||
|
|
weight: connection.weight
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
var index = json.nodes.length;
|
||
|
|
json.nodes.push({
|
||
|
|
id: index,
|
||
|
|
activation: connection.gater.activation,
|
||
|
|
name: "GATE"
|
||
|
|
});
|
||
|
|
json.links.push({
|
||
|
|
source: this.nodes.indexOf(connection.from),
|
||
|
|
target: index,
|
||
|
|
weight: 1 / 2 * connection.weight
|
||
|
|
});
|
||
|
|
json.links.push({
|
||
|
|
source: index,
|
||
|
|
target: this.nodes.indexOf(connection.to),
|
||
|
|
weight: 1 / 2 * connection.weight
|
||
|
|
});
|
||
|
|
json.links.push({
|
||
|
|
source: this.nodes.indexOf(connection.gater),
|
||
|
|
target: index,
|
||
|
|
weight: connection.gater.activation,
|
||
|
|
gate: true
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return json;
|
||
|
|
},
|
||
|
|
toJSON: function() {
|
||
|
|
var json = {
|
||
|
|
nodes: [],
|
||
|
|
connections: [],
|
||
|
|
input: this.input,
|
||
|
|
output: this.output,
|
||
|
|
dropout: this.dropout
|
||
|
|
};
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
this.nodes[i].index = i;
|
||
|
|
}
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
let node = this.nodes[i];
|
||
|
|
let tojson = node.toJSON();
|
||
|
|
tojson.index = i;
|
||
|
|
json.nodes.push(tojson);
|
||
|
|
if (node.connections.self.weight !== 0) {
|
||
|
|
let tojson2 = node.connections.self.toJSON();
|
||
|
|
tojson2.from = i;
|
||
|
|
tojson2.to = i;
|
||
|
|
tojson2.gater = node.connections.self.gater != null ? node.connections.self.gater.index : null;
|
||
|
|
json.connections.push(tojson2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (i = 0; i < this.connections.length; i++) {
|
||
|
|
let conn = this.connections[i];
|
||
|
|
let tojson = conn.toJSON();
|
||
|
|
tojson.from = conn.from.index;
|
||
|
|
tojson.to = conn.to.index;
|
||
|
|
tojson.gater = conn.gater != null ? conn.gater.index : null;
|
||
|
|
json.connections.push(tojson);
|
||
|
|
}
|
||
|
|
return json;
|
||
|
|
},
|
||
|
|
set: function(values) {
|
||
|
|
for (var i = 0; i < this.nodes.length; i++) {
|
||
|
|
this.nodes[i].bias = values.bias || this.nodes[i].bias;
|
||
|
|
this.nodes[i].squash = values.squash || this.nodes[i].squash;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
evolve: async function(set, options) {
|
||
|
|
if (set[0].input.length !== this.input || set[0].output.length !== this.output) {
|
||
|
|
throw new Error("Dataset input/output size should be same as network input/output size!");
|
||
|
|
}
|
||
|
|
options = options || {};
|
||
|
|
var targetError = typeof options.error !== "undefined" ? options.error : 0.05;
|
||
|
|
var growth = typeof options.growth !== "undefined" ? options.growth : 1e-4;
|
||
|
|
var cost = options.cost || methods.cost.MSE;
|
||
|
|
var amount = options.amount || 1;
|
||
|
|
var threads = options.threads;
|
||
|
|
if (typeof threads === "undefined") {
|
||
|
|
if (typeof window === "undefined") {
|
||
|
|
threads = (init_os(), os_exports).cpus().length;
|
||
|
|
} else {
|
||
|
|
threads = navigator.hardwareConcurrency;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var start = Date.now();
|
||
|
|
if (typeof options.iterations === "undefined" && typeof options.error === "undefined") {
|
||
|
|
throw new Error("At least one of the following options must be specified: error, iterations");
|
||
|
|
} else if (typeof options.error === "undefined") {
|
||
|
|
targetError = -1;
|
||
|
|
} else if (typeof options.iterations === "undefined") {
|
||
|
|
options.iterations = 0;
|
||
|
|
}
|
||
|
|
var fitnessFunction;
|
||
|
|
if (threads === 1) {
|
||
|
|
fitnessFunction = function(genome) {
|
||
|
|
var score = 0;
|
||
|
|
for (var i2 = 0; i2 < amount; i2++) {
|
||
|
|
score -= genome.test(set, cost).error;
|
||
|
|
}
|
||
|
|
score -= (genome.nodes.length - genome.input - genome.output + genome.connections.length + genome.gates.length) * growth;
|
||
|
|
score = isNaN(score) ? -Infinity : score;
|
||
|
|
return score / amount;
|
||
|
|
};
|
||
|
|
} else {
|
||
|
|
var converted = multi.serializeDataSet(set);
|
||
|
|
var workers = [];
|
||
|
|
if (typeof window === "undefined") {
|
||
|
|
for (var i = 0; i < threads; i++) {
|
||
|
|
workers.push(new multi.workers.node.TestWorker(converted, cost));
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (var i = 0; i < threads; i++) {
|
||
|
|
workers.push(new multi.workers.browser.TestWorker(converted, cost));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
fitnessFunction = function(population) {
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
var queue = population.slice();
|
||
|
|
var done = 0;
|
||
|
|
var startWorker = function(worker) {
|
||
|
|
if (!queue.length) {
|
||
|
|
if (++done === threads)
|
||
|
|
resolve();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var genome = queue.shift();
|
||
|
|
worker.evaluate(genome).then(function(result) {
|
||
|
|
genome.score = -result;
|
||
|
|
genome.score -= (genome.nodes.length - genome.input - genome.output + genome.connections.length + genome.gates.length) * growth;
|
||
|
|
genome.score = isNaN(parseFloat(result)) ? -Infinity : genome.score;
|
||
|
|
startWorker(worker);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
for (var i2 = 0; i2 < workers.length; i2++) {
|
||
|
|
startWorker(workers[i2]);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
options.fitnessPopulation = true;
|
||
|
|
}
|
||
|
|
options.network = this;
|
||
|
|
var neat = new Neat(this.input, this.output, fitnessFunction, options);
|
||
|
|
var error = -Infinity;
|
||
|
|
var bestFitness = -Infinity;
|
||
|
|
var bestGenome;
|
||
|
|
while (error < -targetError && (options.iterations === 0 || neat.generation < options.iterations)) {
|
||
|
|
let fittest = await neat.evolve();
|
||
|
|
let fitness = fittest.score;
|
||
|
|
error = fitness + (fittest.nodes.length - fittest.input - fittest.output + fittest.connections.length + fittest.gates.length) * growth;
|
||
|
|
if (fitness > bestFitness) {
|
||
|
|
bestFitness = fitness;
|
||
|
|
bestGenome = fittest;
|
||
|
|
}
|
||
|
|
if (options.log && neat.generation % options.log === 0) {
|
||
|
|
console.log("iteration", neat.generation, "fitness", fitness, "error", -error);
|
||
|
|
}
|
||
|
|
if (options.schedule && neat.generation % options.schedule.iterations === 0) {
|
||
|
|
options.schedule.function({ fitness, error: -error, iteration: neat.generation });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (threads > 1) {
|
||
|
|
for (var i = 0; i < workers.length; i++)
|
||
|
|
workers[i].terminate();
|
||
|
|
}
|
||
|
|
if (typeof bestGenome !== "undefined") {
|
||
|
|
this.nodes = bestGenome.nodes;
|
||
|
|
this.connections = bestGenome.connections;
|
||
|
|
this.selfconns = bestGenome.selfconns;
|
||
|
|
this.gates = bestGenome.gates;
|
||
|
|
if (options.clear)
|
||
|
|
this.clear();
|
||
|
|
}
|
||
|
|
return {
|
||
|
|
error: -error,
|
||
|
|
iterations: neat.generation,
|
||
|
|
time: Date.now() - start
|
||
|
|
};
|
||
|
|
},
|
||
|
|
standalone: function() {
|
||
|
|
var present = [];
|
||
|
|
var activations = [];
|
||
|
|
var states = [];
|
||
|
|
var lines = [];
|
||
|
|
var functions = [];
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < this.input; i++) {
|
||
|
|
var node = this.nodes[i];
|
||
|
|
activations.push(node.activation);
|
||
|
|
states.push(node.state);
|
||
|
|
}
|
||
|
|
lines.push("for(var i = 0; i < input.length; i++) A[i] = input[i];");
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
this.nodes[i].index = i;
|
||
|
|
}
|
||
|
|
for (i = this.input; i < this.nodes.length; i++) {
|
||
|
|
let node2 = this.nodes[i];
|
||
|
|
activations.push(node2.activation);
|
||
|
|
states.push(node2.state);
|
||
|
|
var functionIndex = present.indexOf(node2.squash.name);
|
||
|
|
if (functionIndex === -1) {
|
||
|
|
functionIndex = present.length;
|
||
|
|
present.push(node2.squash.name);
|
||
|
|
functions.push(node2.squash.toString());
|
||
|
|
}
|
||
|
|
var incoming = [];
|
||
|
|
for (var j = 0; j < node2.connections.in.length; j++) {
|
||
|
|
var conn = node2.connections.in[j];
|
||
|
|
var computation = `A[${conn.from.index}] * ${conn.weight}`;
|
||
|
|
if (conn.gater != null) {
|
||
|
|
computation += ` * A[${conn.gater.index}]`;
|
||
|
|
}
|
||
|
|
incoming.push(computation);
|
||
|
|
}
|
||
|
|
if (node2.connections.self.weight) {
|
||
|
|
let conn2 = node2.connections.self;
|
||
|
|
let computation2 = `S[${i}] * ${conn2.weight}`;
|
||
|
|
if (conn2.gater != null) {
|
||
|
|
computation2 += ` * A[${conn2.gater.index}]`;
|
||
|
|
}
|
||
|
|
incoming.push(computation2);
|
||
|
|
}
|
||
|
|
var line1 = `S[${i}] = ${incoming.join(" + ")} + ${node2.bias};`;
|
||
|
|
var line2 = `A[${i}] = F[${functionIndex}](S[${i}])${!node2.mask ? " * " + node2.mask : ""};`;
|
||
|
|
lines.push(line1);
|
||
|
|
lines.push(line2);
|
||
|
|
}
|
||
|
|
var output = [];
|
||
|
|
for (i = this.nodes.length - this.output; i < this.nodes.length; i++) {
|
||
|
|
output.push(`A[${i}]`);
|
||
|
|
}
|
||
|
|
output = `return [${output.join(",")}];`;
|
||
|
|
lines.push(output);
|
||
|
|
var total = "";
|
||
|
|
total += `var F = [${functions.toString()}];\r
|
||
|
|
`;
|
||
|
|
total += `var A = [${activations.toString()}];\r
|
||
|
|
`;
|
||
|
|
total += `var S = [${states.toString()}];\r
|
||
|
|
`;
|
||
|
|
total += `function activate(input){\r
|
||
|
|
${lines.join("\r\n")}\r
|
||
|
|
}`;
|
||
|
|
return total;
|
||
|
|
},
|
||
|
|
serialize: function() {
|
||
|
|
var activations = [];
|
||
|
|
var states = [];
|
||
|
|
var conns = [];
|
||
|
|
var squashes = [
|
||
|
|
"LOGISTIC",
|
||
|
|
"TANH",
|
||
|
|
"IDENTITY",
|
||
|
|
"STEP",
|
||
|
|
"RELU",
|
||
|
|
"SOFTSIGN",
|
||
|
|
"SINUSOID",
|
||
|
|
"GAUSSIAN",
|
||
|
|
"BENT_IDENTITY",
|
||
|
|
"BIPOLAR",
|
||
|
|
"BIPOLAR_SIGMOID",
|
||
|
|
"HARD_TANH",
|
||
|
|
"ABSOLUTE",
|
||
|
|
"INVERSE",
|
||
|
|
"SELU"
|
||
|
|
];
|
||
|
|
conns.push(this.input);
|
||
|
|
conns.push(this.output);
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
let node = this.nodes[i];
|
||
|
|
node.index = i;
|
||
|
|
activations.push(node.activation);
|
||
|
|
states.push(node.state);
|
||
|
|
}
|
||
|
|
for (i = this.input; i < this.nodes.length; i++) {
|
||
|
|
let node = this.nodes[i];
|
||
|
|
conns.push(node.index);
|
||
|
|
conns.push(node.bias);
|
||
|
|
conns.push(squashes.indexOf(node.squash.name));
|
||
|
|
conns.push(node.connections.self.weight);
|
||
|
|
conns.push(node.connections.self.gater == null ? -1 : node.connections.self.gater.index);
|
||
|
|
for (var j = 0; j < node.connections.in.length; j++) {
|
||
|
|
let conn = node.connections.in[j];
|
||
|
|
conns.push(conn.from.index);
|
||
|
|
conns.push(conn.weight);
|
||
|
|
conns.push(conn.gater == null ? -1 : conn.gater.index);
|
||
|
|
}
|
||
|
|
conns.push(-2);
|
||
|
|
}
|
||
|
|
return [activations, states, conns];
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Network.fromJSON = function(json) {
|
||
|
|
var network = new Network(json.input, json.output);
|
||
|
|
network.dropout = json.dropout;
|
||
|
|
network.nodes = [];
|
||
|
|
network.connections = [];
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < json.nodes.length; i++) {
|
||
|
|
network.nodes.push(Node.fromJSON(json.nodes[i]));
|
||
|
|
}
|
||
|
|
for (i = 0; i < json.connections.length; i++) {
|
||
|
|
var conn = json.connections[i];
|
||
|
|
var connection = network.connect(network.nodes[conn.from], network.nodes[conn.to])[0];
|
||
|
|
connection.weight = conn.weight;
|
||
|
|
if (conn.gater != null) {
|
||
|
|
network.gate(network.nodes[conn.gater], connection);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return network;
|
||
|
|
};
|
||
|
|
Network.merge = function(network1, network2) {
|
||
|
|
network1 = Network.fromJSON(network1.toJSON());
|
||
|
|
network2 = Network.fromJSON(network2.toJSON());
|
||
|
|
if (network1.output !== network2.input) {
|
||
|
|
throw new Error("Output size of network1 should be the same as the input size of network2!");
|
||
|
|
}
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < network2.connections.length; i++) {
|
||
|
|
let conn = network2.connections[i];
|
||
|
|
if (conn.from.type === "input") {
|
||
|
|
let index = network2.nodes.indexOf(conn.from);
|
||
|
|
conn.from = network1.nodes[network1.nodes.length - 1 - index];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (i = network2.input - 1; i >= 0; i--) {
|
||
|
|
network2.nodes.splice(i, 1);
|
||
|
|
}
|
||
|
|
for (i = network1.nodes.length - network1.output; i < network1.nodes.length; i++) {
|
||
|
|
network1.nodes[i].type = "hidden";
|
||
|
|
}
|
||
|
|
network1.connections = network1.connections.concat(network2.connections);
|
||
|
|
network1.nodes = network1.nodes.concat(network2.nodes);
|
||
|
|
return network1;
|
||
|
|
};
|
||
|
|
Network.crossOver = function(network1, network2, equal) {
|
||
|
|
if (network1.input !== network2.input || network1.output !== network2.output) {
|
||
|
|
throw new Error("Networks don't have the same input/output size!");
|
||
|
|
}
|
||
|
|
var offspring = new Network(network1.input, network1.output);
|
||
|
|
offspring.connections = [];
|
||
|
|
offspring.nodes = [];
|
||
|
|
var score1 = network1.score || 0;
|
||
|
|
var score2 = network2.score || 0;
|
||
|
|
var size;
|
||
|
|
if (equal || score1 === score2) {
|
||
|
|
let max = Math.max(network1.nodes.length, network2.nodes.length);
|
||
|
|
let min = Math.min(network1.nodes.length, network2.nodes.length);
|
||
|
|
size = Math.floor(Math.random() * (max - min + 1) + min);
|
||
|
|
} else if (score1 > score2) {
|
||
|
|
size = network1.nodes.length;
|
||
|
|
} else {
|
||
|
|
size = network2.nodes.length;
|
||
|
|
}
|
||
|
|
var outputSize = network1.output;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < network1.nodes.length; i++) {
|
||
|
|
network1.nodes[i].index = i;
|
||
|
|
}
|
||
|
|
for (i = 0; i < network2.nodes.length; i++) {
|
||
|
|
network2.nodes[i].index = i;
|
||
|
|
}
|
||
|
|
for (i = 0; i < size; i++) {
|
||
|
|
var node;
|
||
|
|
if (i < size - outputSize) {
|
||
|
|
let random = Math.random();
|
||
|
|
node = random >= 0.5 ? network1.nodes[i] : network2.nodes[i];
|
||
|
|
let other = random < 0.5 ? network1.nodes[i] : network2.nodes[i];
|
||
|
|
if (typeof node === "undefined" || node.type === "output") {
|
||
|
|
node = other;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (Math.random() >= 0.5) {
|
||
|
|
node = network1.nodes[network1.nodes.length + i - size];
|
||
|
|
} else {
|
||
|
|
node = network2.nodes[network2.nodes.length + i - size];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var newNode = new Node();
|
||
|
|
newNode.bias = node.bias;
|
||
|
|
newNode.squash = node.squash;
|
||
|
|
newNode.type = node.type;
|
||
|
|
offspring.nodes.push(newNode);
|
||
|
|
}
|
||
|
|
var n1conns = {};
|
||
|
|
var n2conns = {};
|
||
|
|
for (i = 0; i < network1.connections.length; i++) {
|
||
|
|
let conn = network1.connections[i];
|
||
|
|
let data = {
|
||
|
|
weight: conn.weight,
|
||
|
|
from: conn.from.index,
|
||
|
|
to: conn.to.index,
|
||
|
|
gater: conn.gater != null ? conn.gater.index : -1
|
||
|
|
};
|
||
|
|
n1conns[Connection.innovationID(data.from, data.to)] = data;
|
||
|
|
}
|
||
|
|
for (i = 0; i < network1.selfconns.length; i++) {
|
||
|
|
let conn = network1.selfconns[i];
|
||
|
|
let data = {
|
||
|
|
weight: conn.weight,
|
||
|
|
from: conn.from.index,
|
||
|
|
to: conn.to.index,
|
||
|
|
gater: conn.gater != null ? conn.gater.index : -1
|
||
|
|
};
|
||
|
|
n1conns[Connection.innovationID(data.from, data.to)] = data;
|
||
|
|
}
|
||
|
|
for (i = 0; i < network2.connections.length; i++) {
|
||
|
|
let conn = network2.connections[i];
|
||
|
|
let data = {
|
||
|
|
weight: conn.weight,
|
||
|
|
from: conn.from.index,
|
||
|
|
to: conn.to.index,
|
||
|
|
gater: conn.gater != null ? conn.gater.index : -1
|
||
|
|
};
|
||
|
|
n2conns[Connection.innovationID(data.from, data.to)] = data;
|
||
|
|
}
|
||
|
|
for (i = 0; i < network2.selfconns.length; i++) {
|
||
|
|
let conn = network2.selfconns[i];
|
||
|
|
let data = {
|
||
|
|
weight: conn.weight,
|
||
|
|
from: conn.from.index,
|
||
|
|
to: conn.to.index,
|
||
|
|
gater: conn.gater != null ? conn.gater.index : -1
|
||
|
|
};
|
||
|
|
n2conns[Connection.innovationID(data.from, data.to)] = data;
|
||
|
|
}
|
||
|
|
var connections = [];
|
||
|
|
var keys1 = Object.keys(n1conns);
|
||
|
|
var keys2 = Object.keys(n2conns);
|
||
|
|
for (i = keys1.length - 1; i >= 0; i--) {
|
||
|
|
if (typeof n2conns[keys1[i]] !== "undefined") {
|
||
|
|
let conn = Math.random() >= 0.5 ? n1conns[keys1[i]] : n2conns[keys1[i]];
|
||
|
|
connections.push(conn);
|
||
|
|
n2conns[keys1[i]] = void 0;
|
||
|
|
} else if (score1 >= score2 || equal) {
|
||
|
|
connections.push(n1conns[keys1[i]]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (score2 >= score1 || equal) {
|
||
|
|
for (i = 0; i < keys2.length; i++) {
|
||
|
|
if (typeof n2conns[keys2[i]] !== "undefined") {
|
||
|
|
connections.push(n2conns[keys2[i]]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (i = 0; i < connections.length; i++) {
|
||
|
|
let connData = connections[i];
|
||
|
|
if (connData.to < size && connData.from < size) {
|
||
|
|
let from = offspring.nodes[connData.from];
|
||
|
|
let to = offspring.nodes[connData.to];
|
||
|
|
let conn = offspring.connect(from, to)[0];
|
||
|
|
conn.weight = connData.weight;
|
||
|
|
if (connData.gater !== -1 && connData.gater < size) {
|
||
|
|
offspring.gate(offspring.nodes[connData.gater], conn);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return offspring;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/architecture/layer.js
|
||
|
|
var require_layer = __commonJS({
|
||
|
|
"node_modules/neataptic/src/architecture/layer.js"(exports, module) {
|
||
|
|
module.exports = Layer;
|
||
|
|
var methods = require_methods();
|
||
|
|
var Group = require_group();
|
||
|
|
var Node = require_node();
|
||
|
|
function Layer() {
|
||
|
|
this.output = null;
|
||
|
|
this.nodes = [];
|
||
|
|
this.connections = {
|
||
|
|
in: [],
|
||
|
|
out: [],
|
||
|
|
self: []
|
||
|
|
};
|
||
|
|
}
|
||
|
|
Layer.prototype = {
|
||
|
|
activate: function(value) {
|
||
|
|
var values = [];
|
||
|
|
if (typeof value !== "undefined" && value.length !== this.nodes.length) {
|
||
|
|
throw new Error("Array with values should be same as the amount of nodes!");
|
||
|
|
}
|
||
|
|
for (var i = 0; i < this.nodes.length; i++) {
|
||
|
|
var activation;
|
||
|
|
if (typeof value === "undefined") {
|
||
|
|
activation = this.nodes[i].activate();
|
||
|
|
} else {
|
||
|
|
activation = this.nodes[i].activate(value[i]);
|
||
|
|
}
|
||
|
|
values.push(activation);
|
||
|
|
}
|
||
|
|
return values;
|
||
|
|
},
|
||
|
|
propagate: function(rate, momentum, target) {
|
||
|
|
if (typeof target !== "undefined" && target.length !== this.nodes.length) {
|
||
|
|
throw new Error("Array with values should be same as the amount of nodes!");
|
||
|
|
}
|
||
|
|
for (var i = this.nodes.length - 1; i >= 0; i--) {
|
||
|
|
if (typeof target === "undefined") {
|
||
|
|
this.nodes[i].propagate(rate, momentum, true);
|
||
|
|
} else {
|
||
|
|
this.nodes[i].propagate(rate, momentum, true, target[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
connect: function(target, method, weight) {
|
||
|
|
var connections;
|
||
|
|
if (target instanceof Group || target instanceof Node) {
|
||
|
|
connections = this.output.connect(target, method, weight);
|
||
|
|
} else if (target instanceof Layer) {
|
||
|
|
connections = target.input(this, method, weight);
|
||
|
|
}
|
||
|
|
return connections;
|
||
|
|
},
|
||
|
|
gate: function(connections, method) {
|
||
|
|
this.output.gate(connections, method);
|
||
|
|
},
|
||
|
|
set: function(values) {
|
||
|
|
for (var i = 0; i < this.nodes.length; i++) {
|
||
|
|
var node = this.nodes[i];
|
||
|
|
if (node instanceof Node) {
|
||
|
|
if (typeof values.bias !== "undefined") {
|
||
|
|
node.bias = values.bias;
|
||
|
|
}
|
||
|
|
node.squash = values.squash || node.squash;
|
||
|
|
node.type = values.type || node.type;
|
||
|
|
} else if (node instanceof Group) {
|
||
|
|
node.set(values);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
disconnect: function(target, twosided) {
|
||
|
|
twosided = twosided || false;
|
||
|
|
var i, j, k;
|
||
|
|
if (target instanceof Group) {
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
for (j = 0; j < target.nodes.length; j++) {
|
||
|
|
this.nodes[i].disconnect(target.nodes[j], twosided);
|
||
|
|
for (k = this.connections.out.length - 1; k >= 0; k--) {
|
||
|
|
let conn = this.connections.out[k];
|
||
|
|
if (conn.from === this.nodes[i] && conn.to === target.nodes[j]) {
|
||
|
|
this.connections.out.splice(k, 1);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (twosided) {
|
||
|
|
for (k = this.connections.in.length - 1; k >= 0; k--) {
|
||
|
|
let conn = this.connections.in[k];
|
||
|
|
if (conn.from === target.nodes[j] && conn.to === this.nodes[i]) {
|
||
|
|
this.connections.in.splice(k, 1);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (target instanceof Node) {
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
this.nodes[i].disconnect(target, twosided);
|
||
|
|
for (j = this.connections.out.length - 1; j >= 0; j--) {
|
||
|
|
let conn = this.connections.out[j];
|
||
|
|
if (conn.from === this.nodes[i] && conn.to === target) {
|
||
|
|
this.connections.out.splice(j, 1);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (twosided) {
|
||
|
|
for (k = this.connections.in.length - 1; k >= 0; k--) {
|
||
|
|
let conn = this.connections.in[k];
|
||
|
|
if (conn.from === target && conn.to === this.nodes[i]) {
|
||
|
|
this.connections.in.splice(k, 1);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
clear: function() {
|
||
|
|
for (var i = 0; i < this.nodes.length; i++) {
|
||
|
|
this.nodes[i].clear();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Layer.Dense = function(size) {
|
||
|
|
var layer = new Layer();
|
||
|
|
var block = new Group(size);
|
||
|
|
layer.nodes.push(block);
|
||
|
|
layer.output = block;
|
||
|
|
layer.input = function(from, method, weight) {
|
||
|
|
if (from instanceof Layer)
|
||
|
|
from = from.output;
|
||
|
|
method = method || methods.connection.ALL_TO_ALL;
|
||
|
|
return from.connect(block, method, weight);
|
||
|
|
};
|
||
|
|
return layer;
|
||
|
|
};
|
||
|
|
Layer.LSTM = function(size) {
|
||
|
|
var layer = new Layer();
|
||
|
|
var inputGate = new Group(size);
|
||
|
|
var forgetGate = new Group(size);
|
||
|
|
var memoryCell = new Group(size);
|
||
|
|
var outputGate = new Group(size);
|
||
|
|
var outputBlock = new Group(size);
|
||
|
|
inputGate.set({
|
||
|
|
bias: 1
|
||
|
|
});
|
||
|
|
forgetGate.set({
|
||
|
|
bias: 1
|
||
|
|
});
|
||
|
|
outputGate.set({
|
||
|
|
bias: 1
|
||
|
|
});
|
||
|
|
memoryCell.connect(inputGate, methods.connection.ALL_TO_ALL);
|
||
|
|
memoryCell.connect(forgetGate, methods.connection.ALL_TO_ALL);
|
||
|
|
memoryCell.connect(outputGate, methods.connection.ALL_TO_ALL);
|
||
|
|
var forget = memoryCell.connect(memoryCell, methods.connection.ONE_TO_ONE);
|
||
|
|
var output = memoryCell.connect(outputBlock, methods.connection.ALL_TO_ALL);
|
||
|
|
forgetGate.gate(forget, methods.gating.SELF);
|
||
|
|
outputGate.gate(output, methods.gating.OUTPUT);
|
||
|
|
layer.nodes = [inputGate, forgetGate, memoryCell, outputGate, outputBlock];
|
||
|
|
layer.output = outputBlock;
|
||
|
|
layer.input = function(from, method, weight) {
|
||
|
|
if (from instanceof Layer)
|
||
|
|
from = from.output;
|
||
|
|
method = method || methods.connection.ALL_TO_ALL;
|
||
|
|
var connections = [];
|
||
|
|
var input = from.connect(memoryCell, method, weight);
|
||
|
|
connections = connections.concat(input);
|
||
|
|
connections = connections.concat(from.connect(inputGate, method, weight));
|
||
|
|
connections = connections.concat(from.connect(outputGate, method, weight));
|
||
|
|
connections = connections.concat(from.connect(forgetGate, method, weight));
|
||
|
|
inputGate.gate(input, methods.gating.INPUT);
|
||
|
|
return connections;
|
||
|
|
};
|
||
|
|
return layer;
|
||
|
|
};
|
||
|
|
Layer.GRU = function(size) {
|
||
|
|
var layer = new Layer();
|
||
|
|
var updateGate = new Group(size);
|
||
|
|
var inverseUpdateGate = new Group(size);
|
||
|
|
var resetGate = new Group(size);
|
||
|
|
var memoryCell = new Group(size);
|
||
|
|
var output = new Group(size);
|
||
|
|
var previousOutput = new Group(size);
|
||
|
|
previousOutput.set({
|
||
|
|
bias: 0,
|
||
|
|
squash: methods.activation.IDENTITY,
|
||
|
|
type: "constant"
|
||
|
|
});
|
||
|
|
memoryCell.set({
|
||
|
|
squash: methods.activation.TANH
|
||
|
|
});
|
||
|
|
inverseUpdateGate.set({
|
||
|
|
bias: 0,
|
||
|
|
squash: methods.activation.INVERSE,
|
||
|
|
type: "constant"
|
||
|
|
});
|
||
|
|
updateGate.set({
|
||
|
|
bias: 1
|
||
|
|
});
|
||
|
|
resetGate.set({
|
||
|
|
bias: 0
|
||
|
|
});
|
||
|
|
previousOutput.connect(updateGate, methods.connection.ALL_TO_ALL);
|
||
|
|
updateGate.connect(inverseUpdateGate, methods.connection.ONE_TO_ONE, 1);
|
||
|
|
previousOutput.connect(resetGate, methods.connection.ALL_TO_ALL);
|
||
|
|
var reset = previousOutput.connect(memoryCell, methods.connection.ALL_TO_ALL);
|
||
|
|
resetGate.gate(reset, methods.gating.OUTPUT);
|
||
|
|
var update1 = previousOutput.connect(output, methods.connection.ALL_TO_ALL);
|
||
|
|
var update2 = memoryCell.connect(output, methods.connection.ALL_TO_ALL);
|
||
|
|
updateGate.gate(update1, methods.gating.OUTPUT);
|
||
|
|
inverseUpdateGate.gate(update2, methods.gating.OUTPUT);
|
||
|
|
output.connect(previousOutput, methods.connection.ONE_TO_ONE, 1);
|
||
|
|
layer.nodes = [updateGate, inverseUpdateGate, resetGate, memoryCell, output, previousOutput];
|
||
|
|
layer.output = output;
|
||
|
|
layer.input = function(from, method, weight) {
|
||
|
|
if (from instanceof Layer)
|
||
|
|
from = from.output;
|
||
|
|
method = method || methods.connection.ALL_TO_ALL;
|
||
|
|
var connections = [];
|
||
|
|
connections = connections.concat(from.connect(updateGate, method, weight));
|
||
|
|
connections = connections.concat(from.connect(resetGate, method, weight));
|
||
|
|
connections = connections.concat(from.connect(memoryCell, method, weight));
|
||
|
|
return connections;
|
||
|
|
};
|
||
|
|
return layer;
|
||
|
|
};
|
||
|
|
Layer.Memory = function(size, memory) {
|
||
|
|
var layer = new Layer();
|
||
|
|
var previous = null;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < memory; i++) {
|
||
|
|
var block = new Group(size);
|
||
|
|
block.set({
|
||
|
|
squash: methods.activation.IDENTITY,
|
||
|
|
bias: 0,
|
||
|
|
type: "constant"
|
||
|
|
});
|
||
|
|
if (previous != null) {
|
||
|
|
previous.connect(block, methods.connection.ONE_TO_ONE, 1);
|
||
|
|
}
|
||
|
|
layer.nodes.push(block);
|
||
|
|
previous = block;
|
||
|
|
}
|
||
|
|
layer.nodes.reverse();
|
||
|
|
for (i = 0; i < layer.nodes.length; i++) {
|
||
|
|
layer.nodes[i].nodes.reverse();
|
||
|
|
}
|
||
|
|
var outputGroup = new Group(0);
|
||
|
|
for (var group in layer.nodes) {
|
||
|
|
outputGroup.nodes = outputGroup.nodes.concat(layer.nodes[group].nodes);
|
||
|
|
}
|
||
|
|
layer.output = outputGroup;
|
||
|
|
layer.input = function(from, method, weight) {
|
||
|
|
if (from instanceof Layer)
|
||
|
|
from = from.output;
|
||
|
|
method = method || methods.connection.ALL_TO_ALL;
|
||
|
|
if (from.nodes.length !== layer.nodes[layer.nodes.length - 1].nodes.length) {
|
||
|
|
throw new Error("Previous layer size must be same as memory size");
|
||
|
|
}
|
||
|
|
return from.connect(layer.nodes[layer.nodes.length - 1], methods.connection.ONE_TO_ONE, 1);
|
||
|
|
};
|
||
|
|
return layer;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/architecture/group.js
|
||
|
|
var require_group = __commonJS({
|
||
|
|
"node_modules/neataptic/src/architecture/group.js"(exports, module) {
|
||
|
|
module.exports = Group;
|
||
|
|
var methods = require_methods();
|
||
|
|
var config = require_config();
|
||
|
|
var Layer = require_layer();
|
||
|
|
var Node = require_node();
|
||
|
|
function Group(size) {
|
||
|
|
this.nodes = [];
|
||
|
|
this.connections = {
|
||
|
|
in: [],
|
||
|
|
out: [],
|
||
|
|
self: []
|
||
|
|
};
|
||
|
|
for (var i = 0; i < size; i++) {
|
||
|
|
this.nodes.push(new Node());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Group.prototype = {
|
||
|
|
activate: function(value) {
|
||
|
|
var values = [];
|
||
|
|
if (typeof value !== "undefined" && value.length !== this.nodes.length) {
|
||
|
|
throw new Error("Array with values should be same as the amount of nodes!");
|
||
|
|
}
|
||
|
|
for (var i = 0; i < this.nodes.length; i++) {
|
||
|
|
var activation;
|
||
|
|
if (typeof value === "undefined") {
|
||
|
|
activation = this.nodes[i].activate();
|
||
|
|
} else {
|
||
|
|
activation = this.nodes[i].activate(value[i]);
|
||
|
|
}
|
||
|
|
values.push(activation);
|
||
|
|
}
|
||
|
|
return values;
|
||
|
|
},
|
||
|
|
propagate: function(rate, momentum, target) {
|
||
|
|
if (typeof target !== "undefined" && target.length !== this.nodes.length) {
|
||
|
|
throw new Error("Array with values should be same as the amount of nodes!");
|
||
|
|
}
|
||
|
|
for (var i = this.nodes.length - 1; i >= 0; i--) {
|
||
|
|
if (typeof target === "undefined") {
|
||
|
|
this.nodes[i].propagate(rate, momentum, true);
|
||
|
|
} else {
|
||
|
|
this.nodes[i].propagate(rate, momentum, true, target[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
connect: function(target, method, weight) {
|
||
|
|
var connections = [];
|
||
|
|
var i, j;
|
||
|
|
if (target instanceof Group) {
|
||
|
|
if (typeof method === "undefined") {
|
||
|
|
if (this !== target) {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No group connection specified, using ALL_TO_ALL");
|
||
|
|
method = methods.connection.ALL_TO_ALL;
|
||
|
|
} else {
|
||
|
|
if (config.warnings)
|
||
|
|
console.warn("No group connection specified, using ONE_TO_ONE");
|
||
|
|
method = methods.connection.ONE_TO_ONE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (method === methods.connection.ALL_TO_ALL || method === methods.connection.ALL_TO_ELSE) {
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
for (j = 0; j < target.nodes.length; j++) {
|
||
|
|
if (method === methods.connection.ALL_TO_ELSE && this.nodes[i] === target.nodes[j])
|
||
|
|
continue;
|
||
|
|
let connection = this.nodes[i].connect(target.nodes[j], weight);
|
||
|
|
this.connections.out.push(connection[0]);
|
||
|
|
target.connections.in.push(connection[0]);
|
||
|
|
connections.push(connection[0]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (method === methods.connection.ONE_TO_ONE) {
|
||
|
|
if (this.nodes.length !== target.nodes.length) {
|
||
|
|
throw new Error("From and To group must be the same size!");
|
||
|
|
}
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
let connection = this.nodes[i].connect(target.nodes[i], weight);
|
||
|
|
this.connections.self.push(connection[0]);
|
||
|
|
connections.push(connection[0]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (target instanceof Layer) {
|
||
|
|
connections = target.input(this, method, weight);
|
||
|
|
} else if (target instanceof Node) {
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
let connection = this.nodes[i].connect(target, weight);
|
||
|
|
this.connections.out.push(connection[0]);
|
||
|
|
connections.push(connection[0]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return connections;
|
||
|
|
},
|
||
|
|
gate: function(connections, method) {
|
||
|
|
if (typeof method === "undefined") {
|
||
|
|
throw new Error("Please specify Gating.INPUT, Gating.OUTPUT");
|
||
|
|
}
|
||
|
|
if (!Array.isArray(connections)) {
|
||
|
|
connections = [connections];
|
||
|
|
}
|
||
|
|
var nodes1 = [];
|
||
|
|
var nodes2 = [];
|
||
|
|
var i, j;
|
||
|
|
for (i = 0; i < connections.length; i++) {
|
||
|
|
var connection = connections[i];
|
||
|
|
if (!nodes1.includes(connection.from))
|
||
|
|
nodes1.push(connection.from);
|
||
|
|
if (!nodes2.includes(connection.to))
|
||
|
|
nodes2.push(connection.to);
|
||
|
|
}
|
||
|
|
switch (method) {
|
||
|
|
case methods.gating.INPUT:
|
||
|
|
for (i = 0; i < nodes2.length; i++) {
|
||
|
|
let node = nodes2[i];
|
||
|
|
let gater = this.nodes[i % this.nodes.length];
|
||
|
|
for (j = 0; j < node.connections.in.length; j++) {
|
||
|
|
let conn = node.connections.in[j];
|
||
|
|
if (connections.includes(conn)) {
|
||
|
|
gater.gate(conn);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case methods.gating.OUTPUT:
|
||
|
|
for (i = 0; i < nodes1.length; i++) {
|
||
|
|
let node = nodes1[i];
|
||
|
|
let gater = this.nodes[i % this.nodes.length];
|
||
|
|
for (j = 0; j < node.connections.out.length; j++) {
|
||
|
|
let conn = node.connections.out[j];
|
||
|
|
if (connections.includes(conn)) {
|
||
|
|
gater.gate(conn);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case methods.gating.SELF:
|
||
|
|
for (i = 0; i < nodes1.length; i++) {
|
||
|
|
let node = nodes1[i];
|
||
|
|
let gater = this.nodes[i % this.nodes.length];
|
||
|
|
if (connections.includes(node.connections.self)) {
|
||
|
|
gater.gate(node.connections.self);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
set: function(values) {
|
||
|
|
for (var i = 0; i < this.nodes.length; i++) {
|
||
|
|
if (typeof values.bias !== "undefined") {
|
||
|
|
this.nodes[i].bias = values.bias;
|
||
|
|
}
|
||
|
|
this.nodes[i].squash = values.squash || this.nodes[i].squash;
|
||
|
|
this.nodes[i].type = values.type || this.nodes[i].type;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
disconnect: function(target, twosided) {
|
||
|
|
twosided = twosided || false;
|
||
|
|
var i, j, k;
|
||
|
|
if (target instanceof Group) {
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
for (j = 0; j < target.nodes.length; j++) {
|
||
|
|
this.nodes[i].disconnect(target.nodes[j], twosided);
|
||
|
|
for (k = this.connections.out.length - 1; k >= 0; k--) {
|
||
|
|
let conn2 = this.connections.out[k];
|
||
|
|
if (conn2.from === this.nodes[i] && conn2.to === target.nodes[j]) {
|
||
|
|
this.connections.out.splice(k, 1);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (twosided) {
|
||
|
|
for (k = this.connections.in.length - 1; k >= 0; k--) {
|
||
|
|
let conn2 = this.connections.in[k];
|
||
|
|
if (conn2.from === target.nodes[j] && conn2.to === this.nodes[i]) {
|
||
|
|
this.connections.in.splice(k, 1);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (target instanceof Node) {
|
||
|
|
for (i = 0; i < this.nodes.length; i++) {
|
||
|
|
this.nodes[i].disconnect(target, twosided);
|
||
|
|
for (j = this.connections.out.length - 1; j >= 0; j--) {
|
||
|
|
let conn2 = this.connections.out[j];
|
||
|
|
if (conn2.from === this.nodes[i] && conn2.to === target) {
|
||
|
|
this.connections.out.splice(j, 1);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (twosided) {
|
||
|
|
for (j = this.connections.in.length - 1; j >= 0; j--) {
|
||
|
|
var conn = this.connections.in[j];
|
||
|
|
if (conn.from === target && conn.to === this.nodes[i]) {
|
||
|
|
this.connections.in.splice(j, 1);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
clear: function() {
|
||
|
|
for (var i = 0; i < this.nodes.length; i++) {
|
||
|
|
this.nodes[i].clear();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/architecture/architect.js
|
||
|
|
var require_architect = __commonJS({
|
||
|
|
"node_modules/neataptic/src/architecture/architect.js"(exports, module) {
|
||
|
|
var methods = require_methods();
|
||
|
|
var Network = require_network();
|
||
|
|
var Group = require_group();
|
||
|
|
var Layer = require_layer();
|
||
|
|
var Node = require_node();
|
||
|
|
var architect = {
|
||
|
|
Construct: function(list) {
|
||
|
|
var network = new Network(0, 0);
|
||
|
|
var nodes = [];
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < list.length; i++) {
|
||
|
|
let j;
|
||
|
|
if (list[i] instanceof Group) {
|
||
|
|
for (j = 0; j < list[i].nodes.length; j++) {
|
||
|
|
nodes.push(list[i].nodes[j]);
|
||
|
|
}
|
||
|
|
} else if (list[i] instanceof Layer) {
|
||
|
|
for (j = 0; j < list[i].nodes.length; j++) {
|
||
|
|
for (var k = 0; k < list[i].nodes[j].nodes.length; k++) {
|
||
|
|
nodes.push(list[i].nodes[j].nodes[k]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (list[i] instanceof Node) {
|
||
|
|
nodes.push(list[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var inputs = [];
|
||
|
|
var outputs = [];
|
||
|
|
for (i = nodes.length - 1; i >= 0; i--) {
|
||
|
|
if (nodes[i].type === "output" || nodes[i].connections.out.length + nodes[i].connections.gated.length === 0) {
|
||
|
|
nodes[i].type = "output";
|
||
|
|
network.output++;
|
||
|
|
outputs.push(nodes[i]);
|
||
|
|
nodes.splice(i, 1);
|
||
|
|
} else if (nodes[i].type === "input" || !nodes[i].connections.in.length) {
|
||
|
|
nodes[i].type = "input";
|
||
|
|
network.input++;
|
||
|
|
inputs.push(nodes[i]);
|
||
|
|
nodes.splice(i, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
nodes = inputs.concat(nodes).concat(outputs);
|
||
|
|
if (network.input === 0 || network.output === 0) {
|
||
|
|
throw new Error("Given nodes have no clear input/output node!");
|
||
|
|
}
|
||
|
|
for (i = 0; i < nodes.length; i++) {
|
||
|
|
let j;
|
||
|
|
for (j = 0; j < nodes[i].connections.out.length; j++) {
|
||
|
|
network.connections.push(nodes[i].connections.out[j]);
|
||
|
|
}
|
||
|
|
for (j = 0; j < nodes[i].connections.gated.length; j++) {
|
||
|
|
network.gates.push(nodes[i].connections.gated[j]);
|
||
|
|
}
|
||
|
|
if (nodes[i].connections.self.weight !== 0) {
|
||
|
|
network.selfconns.push(nodes[i].connections.self);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
network.nodes = nodes;
|
||
|
|
return network;
|
||
|
|
},
|
||
|
|
Perceptron: function() {
|
||
|
|
var layers = Array.prototype.slice.call(arguments);
|
||
|
|
if (layers.length < 3) {
|
||
|
|
throw new Error("You have to specify at least 3 layers");
|
||
|
|
}
|
||
|
|
var nodes = [];
|
||
|
|
nodes.push(new Group(layers[0]));
|
||
|
|
for (var i = 1; i < layers.length; i++) {
|
||
|
|
var layer = layers[i];
|
||
|
|
layer = new Group(layer);
|
||
|
|
nodes.push(layer);
|
||
|
|
nodes[i - 1].connect(nodes[i], methods.connection.ALL_TO_ALL);
|
||
|
|
}
|
||
|
|
return architect.Construct(nodes);
|
||
|
|
},
|
||
|
|
Random: function(input, hidden, output, options) {
|
||
|
|
options = options || {};
|
||
|
|
var connections = options.connections || hidden * 2;
|
||
|
|
var backconnections = options.backconnections || 0;
|
||
|
|
var selfconnections = options.selfconnections || 0;
|
||
|
|
var gates = options.gates || 0;
|
||
|
|
var network = new Network(input, output);
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < hidden; i++) {
|
||
|
|
network.mutate(methods.mutation.ADD_NODE);
|
||
|
|
}
|
||
|
|
for (i = 0; i < connections - hidden; i++) {
|
||
|
|
network.mutate(methods.mutation.ADD_CONN);
|
||
|
|
}
|
||
|
|
for (i = 0; i < backconnections; i++) {
|
||
|
|
network.mutate(methods.mutation.ADD_BACK_CONN);
|
||
|
|
}
|
||
|
|
for (i = 0; i < selfconnections; i++) {
|
||
|
|
network.mutate(methods.mutation.ADD_SELF_CONN);
|
||
|
|
}
|
||
|
|
for (i = 0; i < gates; i++) {
|
||
|
|
network.mutate(methods.mutation.ADD_GATE);
|
||
|
|
}
|
||
|
|
return network;
|
||
|
|
},
|
||
|
|
LSTM: function() {
|
||
|
|
var args = Array.prototype.slice.call(arguments);
|
||
|
|
if (args.length < 3) {
|
||
|
|
throw new Error("You have to specify at least 3 layers");
|
||
|
|
}
|
||
|
|
var last = args.pop();
|
||
|
|
var outputLayer;
|
||
|
|
if (typeof last === "number") {
|
||
|
|
outputLayer = new Group(last);
|
||
|
|
last = {};
|
||
|
|
} else {
|
||
|
|
outputLayer = new Group(args.pop());
|
||
|
|
}
|
||
|
|
outputLayer.set({
|
||
|
|
type: "output"
|
||
|
|
});
|
||
|
|
var options = {};
|
||
|
|
options.memoryToMemory = last.memoryToMemory || false;
|
||
|
|
options.outputToMemory = last.outputToMemory || false;
|
||
|
|
options.outputToGates = last.outputToGates || false;
|
||
|
|
options.inputToOutput = last.inputToOutput === void 0 ? true : last.inputToOutput;
|
||
|
|
options.inputToDeep = last.inputToDeep === void 0 ? true : last.inputToDeep;
|
||
|
|
var inputLayer = new Group(args.shift());
|
||
|
|
inputLayer.set({
|
||
|
|
type: "input"
|
||
|
|
});
|
||
|
|
var blocks = args;
|
||
|
|
var nodes = [];
|
||
|
|
nodes.push(inputLayer);
|
||
|
|
var previous = inputLayer;
|
||
|
|
for (var i = 0; i < blocks.length; i++) {
|
||
|
|
var block = blocks[i];
|
||
|
|
var inputGate = new Group(block);
|
||
|
|
var forgetGate = new Group(block);
|
||
|
|
var memoryCell = new Group(block);
|
||
|
|
var outputGate = new Group(block);
|
||
|
|
var outputBlock = i === blocks.length - 1 ? outputLayer : new Group(block);
|
||
|
|
inputGate.set({
|
||
|
|
bias: 1
|
||
|
|
});
|
||
|
|
forgetGate.set({
|
||
|
|
bias: 1
|
||
|
|
});
|
||
|
|
outputGate.set({
|
||
|
|
bias: 1
|
||
|
|
});
|
||
|
|
var input = previous.connect(memoryCell, methods.connection.ALL_TO_ALL);
|
||
|
|
previous.connect(inputGate, methods.connection.ALL_TO_ALL);
|
||
|
|
previous.connect(outputGate, methods.connection.ALL_TO_ALL);
|
||
|
|
previous.connect(forgetGate, methods.connection.ALL_TO_ALL);
|
||
|
|
memoryCell.connect(inputGate, methods.connection.ALL_TO_ALL);
|
||
|
|
memoryCell.connect(forgetGate, methods.connection.ALL_TO_ALL);
|
||
|
|
memoryCell.connect(outputGate, methods.connection.ALL_TO_ALL);
|
||
|
|
var forget = memoryCell.connect(memoryCell, methods.connection.ONE_TO_ONE);
|
||
|
|
var output = memoryCell.connect(outputBlock, methods.connection.ALL_TO_ALL);
|
||
|
|
inputGate.gate(input, methods.gating.INPUT);
|
||
|
|
forgetGate.gate(forget, methods.gating.SELF);
|
||
|
|
outputGate.gate(output, methods.gating.OUTPUT);
|
||
|
|
if (options.inputToDeep && i > 0) {
|
||
|
|
let input2 = inputLayer.connect(memoryCell, methods.connection.ALL_TO_ALL);
|
||
|
|
inputGate.gate(input2, methods.gating.INPUT);
|
||
|
|
}
|
||
|
|
if (options.memoryToMemory) {
|
||
|
|
let input2 = memoryCell.connect(memoryCell, methods.connection.ALL_TO_ELSE);
|
||
|
|
inputGate.gate(input2, methods.gating.INPUT);
|
||
|
|
}
|
||
|
|
if (options.outputToMemory) {
|
||
|
|
let input2 = outputLayer.connect(memoryCell, methods.connection.ALL_TO_ALL);
|
||
|
|
inputGate.gate(input2, methods.gating.INPUT);
|
||
|
|
}
|
||
|
|
if (options.outputToGates) {
|
||
|
|
outputLayer.connect(inputGate, methods.connection.ALL_TO_ALL);
|
||
|
|
outputLayer.connect(forgetGate, methods.connection.ALL_TO_ALL);
|
||
|
|
outputLayer.connect(outputGate, methods.connection.ALL_TO_ALL);
|
||
|
|
}
|
||
|
|
nodes.push(inputGate);
|
||
|
|
nodes.push(forgetGate);
|
||
|
|
nodes.push(memoryCell);
|
||
|
|
nodes.push(outputGate);
|
||
|
|
if (i !== blocks.length - 1)
|
||
|
|
nodes.push(outputBlock);
|
||
|
|
previous = outputBlock;
|
||
|
|
}
|
||
|
|
if (options.inputToOutput) {
|
||
|
|
inputLayer.connect(outputLayer, methods.connection.ALL_TO_ALL);
|
||
|
|
}
|
||
|
|
nodes.push(outputLayer);
|
||
|
|
return architect.Construct(nodes);
|
||
|
|
},
|
||
|
|
GRU: function() {
|
||
|
|
var args = Array.prototype.slice.call(arguments);
|
||
|
|
if (args.length < 3) {
|
||
|
|
throw new Error("not enough layers (minimum 3) !!");
|
||
|
|
}
|
||
|
|
var inputLayer = new Group(args.shift());
|
||
|
|
var outputLayer = new Group(args.pop());
|
||
|
|
var blocks = args;
|
||
|
|
var nodes = [];
|
||
|
|
nodes.push(inputLayer);
|
||
|
|
var previous = inputLayer;
|
||
|
|
for (var i = 0; i < blocks.length; i++) {
|
||
|
|
var layer = new Layer.GRU(blocks[i]);
|
||
|
|
previous.connect(layer);
|
||
|
|
previous = layer;
|
||
|
|
nodes.push(layer);
|
||
|
|
}
|
||
|
|
previous.connect(outputLayer);
|
||
|
|
nodes.push(outputLayer);
|
||
|
|
return architect.Construct(nodes);
|
||
|
|
},
|
||
|
|
Hopfield: function(size) {
|
||
|
|
var input = new Group(size);
|
||
|
|
var output = new Group(size);
|
||
|
|
input.connect(output, methods.connection.ALL_TO_ALL);
|
||
|
|
input.set({
|
||
|
|
type: "input"
|
||
|
|
});
|
||
|
|
output.set({
|
||
|
|
squash: methods.activation.STEP,
|
||
|
|
type: "output"
|
||
|
|
});
|
||
|
|
var network = new architect.Construct([input, output]);
|
||
|
|
return network;
|
||
|
|
},
|
||
|
|
NARX: function(inputSize, hiddenLayers, outputSize, previousInput, previousOutput) {
|
||
|
|
if (!Array.isArray(hiddenLayers)) {
|
||
|
|
hiddenLayers = [hiddenLayers];
|
||
|
|
}
|
||
|
|
var nodes = [];
|
||
|
|
var input = new Layer.Dense(inputSize);
|
||
|
|
var inputMemory = new Layer.Memory(inputSize, previousInput);
|
||
|
|
var hidden = [];
|
||
|
|
var output = new Layer.Dense(outputSize);
|
||
|
|
var outputMemory = new Layer.Memory(outputSize, previousOutput);
|
||
|
|
nodes.push(input);
|
||
|
|
nodes.push(outputMemory);
|
||
|
|
for (var i = 0; i < hiddenLayers.length; i++) {
|
||
|
|
var hiddenLayer = new Layer.Dense(hiddenLayers[i]);
|
||
|
|
hidden.push(hiddenLayer);
|
||
|
|
nodes.push(hiddenLayer);
|
||
|
|
if (typeof hidden[i - 1] !== "undefined") {
|
||
|
|
hidden[i - 1].connect(hiddenLayer, methods.connection.ALL_TO_ALL);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
nodes.push(inputMemory);
|
||
|
|
nodes.push(output);
|
||
|
|
input.connect(hidden[0], methods.connection.ALL_TO_ALL);
|
||
|
|
input.connect(inputMemory, methods.connection.ONE_TO_ONE, 1);
|
||
|
|
inputMemory.connect(hidden[0], methods.connection.ALL_TO_ALL);
|
||
|
|
hidden[hidden.length - 1].connect(output, methods.connection.ALL_TO_ALL);
|
||
|
|
output.connect(outputMemory, methods.connection.ONE_TO_ONE, 1);
|
||
|
|
outputMemory.connect(hidden[0], methods.connection.ALL_TO_ALL);
|
||
|
|
input.set({
|
||
|
|
type: "input"
|
||
|
|
});
|
||
|
|
output.set({
|
||
|
|
type: "output"
|
||
|
|
});
|
||
|
|
return architect.Construct(nodes);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
module.exports = architect;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/neataptic/src/neataptic.js
|
||
|
|
var require_neataptic = __commonJS({
|
||
|
|
"node_modules/neataptic/src/neataptic.js"(exports, module) {
|
||
|
|
var Neataptic = {
|
||
|
|
methods: require_methods(),
|
||
|
|
Connection: require_connection2(),
|
||
|
|
architect: require_architect(),
|
||
|
|
Network: require_network(),
|
||
|
|
config: require_config(),
|
||
|
|
Group: require_group(),
|
||
|
|
Layer: require_layer(),
|
||
|
|
Node: require_node(),
|
||
|
|
Neat: require_neat(),
|
||
|
|
multi: require_multi()
|
||
|
|
};
|
||
|
|
if (typeof define !== "undefined" && define.amd) {
|
||
|
|
define([], function() {
|
||
|
|
return Neataptic;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
if (typeof module !== "undefined" && module.exports) {
|
||
|
|
module.exports = Neataptic;
|
||
|
|
}
|
||
|
|
if (typeof window === "object") {
|
||
|
|
(function() {
|
||
|
|
var old = window["neataptic"];
|
||
|
|
Neataptic.ninja = function() {
|
||
|
|
window["neataptic"] = old;
|
||
|
|
return Neataptic;
|
||
|
|
};
|
||
|
|
})();
|
||
|
|
window["neataptic"] = Neataptic;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// dep:neataptic
|
||
|
|
var neataptic_default = require_neataptic();
|
||
|
|
export {
|
||
|
|
neataptic_default as default
|
||
|
|
};
|
||
|
|
//# sourceMappingURL=neataptic.js.map
|