1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
'use strict';
const DEFAULT_WEIGHT_MAX = 4;
const graph_proto = {
connect: function(source, sink, weight) {
return network_connect(this, source, sink, weight);
},
compute: function(inputs, state) {
return network_compute(this, inputs, state);
},
};
export function network(input_count, internal_count, output_count, weight_max = 4) {
const count = input_count + internal_count + output_count;
const n = Object.create(graph_proto);
n.input_count = input_count;
n.output_count = output_count;
n.adjacency = new Array(count).fill([]);
n.weight = [];
return Object.freeze(n);
}
function is_input(n, index) {
return index < n.input_count;
}
function is_output(n, index) {
return index >= (n.adjacency.length - n.output_count);
}
function network_connect(n, source, sink, weight) {
if (is_input(n, sink)) {
// inputs cannot be sinks
throw new Error("attempt to use input as sink");
}
if (is_output(n, source)) {
// outputs cannot be sources
throw new Error("attempt to use output as source");
}
const nn = Object.create(graph_proto);
nn.input_count = n.input_count;
nn.output_count = n.output_count;
nn.adjacency = n.adjacency.map((row, i) => {
if (i === source && i === sink) {
// self-loop
return [...row, 2];
} else if (i === source) {
return [...row, 1];
} else if (i === sink) {
return [...row, -1];
} else {
return [...row, 0];
}
});
nn.weight = [...n.weight, weight];
return Object.freeze(nn);
}
function incident_edges(n, adj) {
const incident = adj
.map((edge, index) => edge < 0 ? index : null)
.filter(index => index !== null);
return incident;
}
function edge_ends(n, edge) {
const ends = n.adjacency
.map((adj, index) => adj[edge] !== 0 ? index : null)
.filter(index => index != null);
ends.sort((a, b) => n.adjacency[a][edge] < n.adjacency[b][edge] ? -1 : 1);
return ends;
}
function get_value(n, index, input) {
if (is_input(n, index)) {
return input[index];
}
const adj = n.adjacency[index];
const incident = incident_edges(n, adj);
const weight = incident.map(x => n.weight[x]);
const sources = incident
.map(x => edge_ends(n, x))
.map(x => x.length === 2 ? x[1] : x[0]);
const sum = sources
.reduce((acc, x, i) => acc + (weight[i] * get_value(n, x, input)), 0);
return Math.tanh(sum);
}
function network_compute(n, input, state) {
const outputs = n.adjacency
.map((x, i) => is_output(n, i) ? i : null)
.filter(i => i !== null);
const output = Object.freeze(
outputs.map(x => get_value(n, x, input))
);
const newstate = Object.freeze([]);
return Object.freeze([output, newstate]);
}
|
