tx · 4eaN4opALriZTmWhQup8C6HqWL7crPbfr84Lp1bNTHu9

3N3n75UqB8G1GKmXFr4zPhKCjGcqJPRSuJY:  -0.01000000 Waves

2024.06.10 00:41 [3143750] smart account 3N3n75UqB8G1GKmXFr4zPhKCjGcqJPRSuJY > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "4eaN4opALriZTmWhQup8C6HqWL7crPbfr84Lp1bNTHu9",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1717969277517,
    "version": 2,
    "chainId": 84,
    "sender": "3N3n75UqB8G1GKmXFr4zPhKCjGcqJPRSuJY",
    "senderPublicKey": "2AWdnJuBMzufXSjTvzVcawBQQhnhF1iXR6QNVgwn33oc",
    "proofs": [
        "61KS9gQoSvyZrG2A2Qm71aKkgcgkx9PY1pyhA7BNJZuzrYypeBsvTCGBqfcdtuwtPfuaHEnqoCfd38sfJ9in9s6i"
    ],
    "script": "base64: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",
    "height": 3143750,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: ypJZ2MuKN8X3n1rSmNHSwMp9hb3Srt4aCAFARzmnC66
Next: 8Z98WBSbg5ME521Bx7gZ74ugVt4yCFseUCkB5daWEzqE

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 7 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
-
let weights_layer_1 = [[440, 263, 80, 832, 157, 871, -3443, 6525, 2264, 12134, 1134, -51353, 1832, -2405, 1360, -201, 2238, -3293, 9374, -4494, -12975, -3745, -843], [-1163, -494, 1955, 3825, 6, -5601, 7277, -8068, -11810, -12438, -4556, 3096, 11035, 8171, -84, -1378, -996, -700, -9483, 1683, 2220, 3393, 6036], [459, 1273, 1002, 442, 138, 2885, -65, 5923, -3229, 10063, 1668, -46093, -5033, 3551, -1014, 1830, -5551, 2703, 11366, -2135, -7642, -7329, -264], [1170, 2070, -475, 483, -1680, -4946, 2839, 1968, 3681, 8620, 7629, 558, -16905, -1707, -1496, 7176, -11104, -87, 12690, 1255, -1548, 564, -5317], [3154, 1899, 447, 692, -274, -2727, 1214, 5594, 8318, 13291, 8885, 5056, -5624, 994, -149, -1587, 857, 2640, 16282, 9880, 3222, 261, -6537], [-1149, 55, 1897, 3704, -175, -6504, 4850, -10116, -11023, -8859, -5620, 2234, 14007, 8143, 1670, -1720, -1043, -3636, -9141, 3771, -3228, 3475, 6004], [-1054, 832, 165, 1606, 768, 616, 79, 4333, 155, 6490, 712, -49359, 3982, -2901, -571, -174, 929, -560, 15438, -34830, -12181, -4678, -3369], [-159, -168, 337, 504, 205, 3078, -1034, 5998, -328, 6437, 708, -53601, 2764, -2814, -1226, 107, -1577, 1545, 9615, -4621, -13957, -2408, -1904], [-888, 1990, 896, 1305, -354, 5662, -2660, 5793, 9015, 16293, 6941, -5088, -8168, -7652, 118, 155, 1068, 4302, 14550, -6067, -2319, -7988, -4884], [810, 1690, 254, 996, -163, 18, 2896, -55376, -9581, -3235, -1320, 1806, 861, 3663, 1263, -52455, -12984, -2928, 744, 781, -550, -702, -2671], [940, 147, 589, 855, -20, 1435, -845, 4281, 3621, 11424, -1055, -38307, 1531, -2608, -1227, -1424, 3285, -2988, 15133, 1012, 1063, -1890, -5082], [576, -188, -206, -123, 284, 2081, -896, 10856, 7790, 8463, 6906, -6140, -8164, -2810, -675, 565, 1479, 2437, 13236, -3503, 42, -4829, -6167], [-1915, 2660, 2177, 4562, 1794, -7883, 5765, -9931, -14914, -8032, -6922, 4421, 8786, 5428, -553, -1148, 650, -1942, -11333, -496, 2843, 2110, 5306], [-73, 6231, 2861, 1939, 267, 3346, -2404, 7073, 7450, 14237, 3593, 484, -9579, -4649, 1681, 753, 779, 1172, 15938, 1131, -2178, -2183, -3288], [-306, 2538, 1410, 2470, 60, 4864, -2122, 6555, 8693, 15462, 7011, 234, -10439, -5629, -1635, 3117, 2215, -193, 17919, 1430, -3699, -1846, -3940]]
4
+
let weights_layer_1 = [[60049, 60073], [41419, 41425]]
5
5
 
6
-
let biases_layer_1 = [3906, 3401, -259, -1042, -1164, 4297, 3329, 1815, 2801, 1590, 1476, 92, 3394, 1949, 2193]
6
+
let biases_layer_1 = [-25905, -63563]
7
7
 
8
-
let weights_layer_2 = [[19327, -3409, 11264, 6095, 7279, -7313, 20721, 21203, 3092, -41727, 4531, -184, -5261, 4689, 2885], [-20754, 5375, -10888, -8381, -8486, 4371, -21296, -20421, -4720, 42861, -5008, 2014, 3364, -3504, -2111]]
8
+
let weights_layer_2 = [[83296, -89714]]
9
9
 
10
-
let biases_layer_2 = [-827, -1849]
10
+
let biases_layer_2 = [-38117]
11
11
 
12
12
 
func linear_forward_1 (input,weights,biases) = {
13
-
    let weighted_sum1 = (((((((((((((((((((((((((input[0] * weights[0][0]) + (input[1] * weights[0][1])) + (input[2] * weights[0][2])) + (input[3] * weights[0][3])) + (input[4] * weights[0][4])) + (input[5] * weights[0][5])) + (input[6] * weights[0][6])) + (input[7] * weights[0][7])) + (input[8] * weights[0][8])) + (input[9] * weights[0][9])) + (input[10] * weights[0][10])) + (input[11] * weights[0][11])) + (input[12] * weights[0][12])) + (input[13] * weights[0][13])) + (input[14] * weights[0][14])) + (input[15] * weights[0][15])) + (input[16] * weights[0][16])) + (input[17] * weights[0][17])) + (input[18] * weights[0][18])) + (input[19] * weights[0][19])) + (input[20] * weights[0][20])) + (input[21] * weights[0][21])) + (input[22] * weights[0][22])) / 10000) + biases[0])
14
-
    let weighted_sum2 = (((((((((((((((((((((((((input[0] * weights[1][0]) + (input[1] * weights[1][1])) + (input[2] * weights[1][2])) + (input[3] * weights[1][3])) + (input[4] * weights[1][4])) + (input[5] * weights[1][5])) + (input[6] * weights[1][6])) + (input[7] * weights[1][7])) + (input[8] * weights[1][8])) + (input[9] * weights[1][9])) + (input[10] * weights[1][10])) + (input[11] * weights[1][11])) + (input[12] * weights[1][12])) + (input[13] * weights[1][13])) + (input[14] * weights[1][14])) + (input[15] * weights[1][15])) + (input[16] * weights[1][16])) + (input[17] * weights[1][17])) + (input[18] * weights[1][18])) + (input[19] * weights[1][19])) + (input[20] * weights[1][20])) + (input[21] * weights[1][21])) + (input[22] * weights[1][22])) / 10000) + biases[1])
15
-
    let weighted_sum3 = (((((((((((((((((((((((((input[0] * weights[2][0]) + (input[1] * weights[2][1])) + (input[2] * weights[2][2])) + (input[3] * weights[2][3])) + (input[4] * weights[2][4])) + (input[5] * weights[2][5])) + (input[6] * weights[2][6])) + (input[7] * weights[2][7])) + (input[8] * weights[2][8])) + (input[9] * weights[2][9])) + (input[10] * weights[2][10])) + (input[11] * weights[2][11])) + (input[12] * weights[2][12])) + (input[13] * weights[2][13])) + (input[14] * weights[2][14])) + (input[15] * weights[2][15])) + (input[16] * weights[2][16])) + (input[17] * weights[2][17])) + (input[18] * weights[2][18])) + (input[19] * weights[2][19])) + (input[20] * weights[2][20])) + (input[21] * weights[2][21])) + (input[22] * weights[2][22])) / 10000) + biases[2])
16
-
    let weighted_sum4 = (((((((((((((((((((((((((input[0] * weights[3][0]) + (input[1] * weights[3][1])) + (input[2] * weights[3][2])) + (input[3] * weights[3][3])) + (input[4] * weights[3][4])) + (input[5] * weights[3][5])) + (input[6] * weights[3][6])) + (input[7] * weights[3][7])) + (input[8] * weights[3][8])) + (input[9] * weights[3][9])) + (input[10] * weights[3][10])) + (input[11] * weights[3][11])) + (input[12] * weights[3][12])) + (input[13] * weights[3][13])) + (input[14] * weights[3][14])) + (input[15] * weights[3][15])) + (input[16] * weights[3][16])) + (input[17] * weights[3][17])) + (input[18] * weights[3][18])) + (input[19] * weights[3][19])) + (input[20] * weights[3][20])) + (input[21] * weights[3][21])) + (input[22] * weights[3][22])) / 10000) + biases[3])
17
-
    let weighted_sum5 = (((((((((((((((((((((((((input[0] * weights[4][0]) + (input[1] * weights[4][1])) + (input[2] * weights[4][2])) + (input[3] * weights[4][3])) + (input[4] * weights[4][4])) + (input[5] * weights[4][5])) + (input[6] * weights[4][6])) + (input[7] * weights[4][7])) + (input[8] * weights[4][8])) + (input[9] * weights[4][9])) + (input[10] * weights[4][10])) + (input[11] * weights[4][11])) + (input[12] * weights[4][12])) + (input[13] * weights[4][13])) + (input[14] * weights[4][14])) + (input[15] * weights[4][15])) + (input[16] * weights[4][16])) + (input[17] * weights[4][17])) + (input[18] * weights[4][18])) + (input[19] * weights[4][19])) + (input[20] * weights[4][20])) + (input[21] * weights[4][21])) + (input[22] * weights[4][22])) / 10000) + biases[4])
18
-
    let weighted_sum6 = (((((((((((((((((((((((((input[0] * weights[5][0]) + (input[1] * weights[5][1])) + (input[2] * weights[5][2])) + (input[3] * weights[5][3])) + (input[4] * weights[5][4])) + (input[5] * weights[5][5])) + (input[6] * weights[5][6])) + (input[7] * weights[5][7])) + (input[8] * weights[5][8])) + (input[9] * weights[5][9])) + (input[10] * weights[5][10])) + (input[11] * weights[5][11])) + (input[12] * weights[5][12])) + (input[13] * weights[5][13])) + (input[14] * weights[5][14])) + (input[15] * weights[5][15])) + (input[16] * weights[5][16])) + (input[17] * weights[5][17])) + (input[18] * weights[5][18])) + (input[19] * weights[5][19])) + (input[20] * weights[5][20])) + (input[21] * weights[5][21])) + (input[22] * weights[5][22])) / 10000) + biases[5])
19
-
    let weighted_sum7 = (((((((((((((((((((((((((input[0] * weights[6][0]) + (input[1] * weights[6][1])) + (input[2] * weights[6][2])) + (input[3] * weights[6][3])) + (input[4] * weights[6][4])) + (input[5] * weights[6][5])) + (input[6] * weights[6][6])) + (input[7] * weights[6][7])) + (input[8] * weights[6][8])) + (input[9] * weights[6][9])) + (input[10] * weights[6][10])) + (input[11] * weights[6][11])) + (input[12] * weights[6][12])) + (input[13] * weights[6][13])) + (input[14] * weights[6][14])) + (input[15] * weights[6][15])) + (input[16] * weights[6][16])) + (input[17] * weights[6][17])) + (input[18] * weights[6][18])) + (input[19] * weights[6][19])) + (input[20] * weights[6][20])) + (input[21] * weights[6][21])) + (input[22] * weights[6][22])) / 10000) + biases[6])
20
-
    let weighted_sum8 = (((((((((((((((((((((((((input[0] * weights[7][0]) + (input[1] * weights[7][1])) + (input[2] * weights[7][2])) + (input[3] * weights[7][3])) + (input[4] * weights[7][4])) + (input[5] * weights[7][5])) + (input[6] * weights[7][6])) + (input[7] * weights[7][7])) + (input[8] * weights[7][8])) + (input[9] * weights[7][9])) + (input[10] * weights[7][10])) + (input[11] * weights[7][11])) + (input[12] * weights[7][12])) + (input[13] * weights[7][13])) + (input[14] * weights[7][14])) + (input[15] * weights[7][15])) + (input[16] * weights[7][16])) + (input[17] * weights[7][17])) + (input[18] * weights[7][18])) + (input[19] * weights[7][19])) + (input[20] * weights[7][20])) + (input[21] * weights[7][21])) + (input[22] * weights[7][22])) / 10000) + biases[7])
21
-
    let weighted_sum9 = (((((((((((((((((((((((((input[0] * weights[8][0]) + (input[1] * weights[8][1])) + (input[2] * weights[8][2])) + (input[3] * weights[8][3])) + (input[4] * weights[8][4])) + (input[5] * weights[8][5])) + (input[6] * weights[8][6])) + (input[7] * weights[8][7])) + (input[8] * weights[8][8])) + (input[9] * weights[8][9])) + (input[10] * weights[8][10])) + (input[11] * weights[8][11])) + (input[12] * weights[8][12])) + (input[13] * weights[8][13])) + (input[14] * weights[8][14])) + (input[15] * weights[8][15])) + (input[16] * weights[8][16])) + (input[17] * weights[8][17])) + (input[18] * weights[8][18])) + (input[19] * weights[8][19])) + (input[20] * weights[8][20])) + (input[21] * weights[8][21])) + (input[22] * weights[8][22])) / 10000) + biases[8])
22
-
    let weighted_sum10 = (((((((((((((((((((((((((input[0] * weights[9][0]) + (input[1] * weights[9][1])) + (input[2] * weights[9][2])) + (input[3] * weights[9][3])) + (input[4] * weights[9][4])) + (input[5] * weights[9][5])) + (input[6] * weights[9][6])) + (input[7] * weights[9][7])) + (input[8] * weights[9][8])) + (input[9] * weights[9][9])) + (input[10] * weights[9][10])) + (input[11] * weights[9][11])) + (input[12] * weights[9][12])) + (input[13] * weights[9][13])) + (input[14] * weights[9][14])) + (input[15] * weights[9][15])) + (input[16] * weights[9][16])) + (input[17] * weights[9][17])) + (input[18] * weights[9][18])) + (input[19] * weights[9][19])) + (input[20] * weights[9][20])) + (input[21] * weights[9][21])) + (input[22] * weights[9][22])) / 10000) + biases[9])
23
-
    let weighted_sum11 = (((((((((((((((((((((((((input[0] * weights[10][0]) + (input[1] * weights[10][1])) + (input[2] * weights[10][2])) + (input[3] * weights[10][3])) + (input[4] * weights[10][4])) + (input[5] * weights[10][5])) + (input[6] * weights[10][6])) + (input[7] * weights[10][7])) + (input[8] * weights[10][8])) + (input[9] * weights[10][9])) + (input[10] * weights[10][10])) + (input[11] * weights[10][11])) + (input[12] * weights[10][12])) + (input[13] * weights[10][13])) + (input[14] * weights[10][14])) + (input[15] * weights[10][15])) + (input[16] * weights[10][16])) + (input[17] * weights[10][17])) + (input[18] * weights[10][18])) + (input[19] * weights[10][19])) + (input[20] * weights[10][20])) + (input[21] * weights[10][21])) + (input[22] * weights[10][22])) / 10000) + biases[10])
24
-
    let weighted_sum12 = (((((((((((((((((((((((((input[0] * weights[11][0]) + (input[1] * weights[11][1])) + (input[2] * weights[11][2])) + (input[3] * weights[11][3])) + (input[4] * weights[11][4])) + (input[5] * weights[11][5])) + (input[6] * weights[11][6])) + (input[7] * weights[11][7])) + (input[8] * weights[11][8])) + (input[9] * weights[11][9])) + (input[10] * weights[11][10])) + (input[11] * weights[11][11])) + (input[12] * weights[11][12])) + (input[13] * weights[11][13])) + (input[14] * weights[11][14])) + (input[15] * weights[11][15])) + (input[16] * weights[11][16])) + (input[17] * weights[11][17])) + (input[18] * weights[11][18])) + (input[19] * weights[11][19])) + (input[20] * weights[11][20])) + (input[21] * weights[11][21])) + (input[22] * weights[11][22])) / 10000) + biases[11])
25
-
    let weighted_sum13 = (((((((((((((((((((((((((input[0] * weights[12][0]) + (input[1] * weights[12][1])) + (input[2] * weights[12][2])) + (input[3] * weights[12][3])) + (input[4] * weights[12][4])) + (input[5] * weights[12][5])) + (input[6] * weights[12][6])) + (input[7] * weights[12][7])) + (input[8] * weights[12][8])) + (input[9] * weights[12][9])) + (input[10] * weights[12][10])) + (input[11] * weights[12][11])) + (input[12] * weights[12][12])) + (input[13] * weights[12][13])) + (input[14] * weights[12][14])) + (input[15] * weights[12][15])) + (input[16] * weights[12][16])) + (input[17] * weights[12][17])) + (input[18] * weights[12][18])) + (input[19] * weights[12][19])) + (input[20] * weights[12][20])) + (input[21] * weights[12][21])) + (input[22] * weights[12][22])) / 10000) + biases[12])
26
-
    let weighted_sum14 = (((((((((((((((((((((((((input[0] * weights[13][0]) + (input[1] * weights[13][1])) + (input[2] * weights[13][2])) + (input[3] * weights[13][3])) + (input[4] * weights[13][4])) + (input[5] * weights[13][5])) + (input[6] * weights[13][6])) + (input[7] * weights[13][7])) + (input[8] * weights[13][8])) + (input[9] * weights[13][9])) + (input[10] * weights[13][10])) + (input[11] * weights[13][11])) + (input[12] * weights[13][12])) + (input[13] * weights[13][13])) + (input[14] * weights[13][14])) + (input[15] * weights[13][15])) + (input[16] * weights[13][16])) + (input[17] * weights[13][17])) + (input[18] * weights[13][18])) + (input[19] * weights[13][19])) + (input[20] * weights[13][20])) + (input[21] * weights[13][21])) + (input[22] * weights[13][22])) / 10000) + biases[13])
27
-
    let weighted_sum15 = (((((((((((((((((((((((((input[0] * weights[14][0]) + (input[1] * weights[14][1])) + (input[2] * weights[14][2])) + (input[3] * weights[14][3])) + (input[4] * weights[14][4])) + (input[5] * weights[14][5])) + (input[6] * weights[14][6])) + (input[7] * weights[14][7])) + (input[8] * weights[14][8])) + (input[9] * weights[14][9])) + (input[10] * weights[14][10])) + (input[11] * weights[14][11])) + (input[12] * weights[14][12])) + (input[13] * weights[14][13])) + (input[14] * weights[14][14])) + (input[15] * weights[14][15])) + (input[16] * weights[14][16])) + (input[17] * weights[14][17])) + (input[18] * weights[14][18])) + (input[19] * weights[14][19])) + (input[20] * weights[14][20])) + (input[21] * weights[14][21])) + (input[22] * weights[14][22])) / 10000) + biases[14])
28
-
[weighted_sum1, weighted_sum2, weighted_sum3, weighted_sum4, weighted_sum5, weighted_sum6, weighted_sum7, weighted_sum8, weighted_sum9, weighted_sum10, weighted_sum11, weighted_sum12, weighted_sum13, weighted_sum14, weighted_sum15]
13
+
    let weighted_sum1 = ((((input[0] * weights[0][0]) + (input[1] * weights[0][1])) / 10000) + biases[0])
14
+
    let weighted_sum2 = ((((input[0] * weights[1][0]) + (input[1] * weights[1][1])) / 10000) + biases[1])
15
+
[weighted_sum1, weighted_sum2]
29
16
 
    }
30
17
 
31
18
 
32
19
 
func linear_forward_2 (input,weights,biases) = {
33
-
    let weighted_sum1 = (((((((((((((((((input[0] * weights[0][0]) + (input[1] * weights[0][1])) + (input[2] * weights[0][2])) + (input[3] * weights[0][3])) + (input[4] * weights[0][4])) + (input[5] * weights[0][5])) + (input[6] * weights[0][6])) + (input[7] * weights[0][7])) + (input[8] * weights[0][8])) + (input[9] * weights[0][9])) + (input[10] * weights[0][10])) + (input[11] * weights[0][11])) + (input[12] * weights[0][12])) + (input[13] * weights[0][13])) + (input[14] * weights[0][14])) / 10000) + biases[0])
34
-
    let weighted_sum2 = (((((((((((((((((input[0] * weights[1][0]) + (input[1] * weights[1][1])) + (input[2] * weights[1][2])) + (input[3] * weights[1][3])) + (input[4] * weights[1][4])) + (input[5] * weights[1][5])) + (input[6] * weights[1][6])) + (input[7] * weights[1][7])) + (input[8] * weights[1][8])) + (input[9] * weights[1][9])) + (input[10] * weights[1][10])) + (input[11] * weights[1][11])) + (input[12] * weights[1][12])) + (input[13] * weights[1][13])) + (input[14] * weights[1][14])) / 10000) + biases[1])
35
-
[weighted_sum1, weighted_sum2]
20
+
    let weighted_sum1 = ((((input[0] * weights[0][0]) + (input[1] * weights[0][1])) / 10000) + biases[0])
21
+
[weighted_sum1]
36
22
 
    }
37
23
 
38
24
 
39
-
func relu (input) = if ((0 > input))
25
+
func sigmoid (input) = if ((-80000 > input))
40
26
 
    then 0
41
-
    else input
27
+
    else if ((-60000 > input))
28
+
        then fraction((input + 80000), 125, 10000)
29
+
        else if ((-40000 > input))
30
+
            then fraction((input + 60000), 100, 10000)
31
+
            else if ((-20000 > input))
32
+
                then fraction((input + 40000), 75, 10000)
33
+
                else if ((0 > input))
34
+
                    then fraction((input + 20000), 50, 10000)
35
+
                    else if ((20000 > input))
36
+
                        then (fraction(input, 50, 10000) + 5000)
37
+
                        else if ((40000 > input))
38
+
                            then (fraction((input - 20000), 75, 10000) + 7500)
39
+
                            else if ((60000 > input))
40
+
                                then (fraction((input - 40000), 100, 10000) + 8750)
41
+
                                else if ((80000 > input))
42
+
                                    then (fraction((input - 60000), 125, 10000) + 9375)
43
+
                                    else 10000
42
44
 
43
45
 
44
-
func relu_activation (inputs,num_outputs) = if ((num_outputs == 1))
45
-
    then [relu(inputs[0])]
46
-
    else [relu(inputs[0]), relu(inputs[1]), relu(inputs[2]), relu(inputs[3]), relu(inputs[4]), relu(inputs[5]), relu(inputs[6]), relu(inputs[7]), relu(inputs[8]), relu(inputs[9]), relu(inputs[10]), relu(inputs[11]), relu(inputs[12]), relu(inputs[13]), relu(inputs[14])]
46
+
func sigmoid_activation (inputs,num_outputs) = if ((num_outputs == 1))
47
+
    then [sigmoid(inputs[0])]
48
+
    else [sigmoid(inputs[0]), sigmoid(inputs[1])]
47
49
 
48
50
 
49
51
 
@Callable(i)
50
52
 
func predict (inputs) = {
51
53
 
    let x1_scaled = (inputs[0] * 10000)
52
54
 
    let x2_scaled = (inputs[1] * 10000)
53
-
    let x3_scaled = (inputs[2] * 10000)
54
-
    let x4_scaled = (inputs[3] * 10000)
55
-
    let x5_scaled = (inputs[4] * 10000)
56
-
    let x6_scaled = (inputs[5] * 10000)
57
-
    let x7_scaled = (inputs[6] * 10000)
58
-
    let x8_scaled = (inputs[7] * 10000)
59
-
    let x9_scaled = (inputs[8] * 10000)
60
-
    let x10_scaled = (inputs[9] * 10000)
61
-
    let x11_scaled = (inputs[10] * 10000)
62
-
    let x12_scaled = (inputs[11] * 10000)
63
-
    let x13_scaled = (inputs[12] * 10000)
64
-
    let x14_scaled = (inputs[13] * 10000)
65
-
    let x15_scaled = (inputs[14] * 10000)
66
-
    let x16_scaled = (inputs[15] * 10000)
67
-
    let x17_scaled = (inputs[16] * 10000)
68
-
    let x18_scaled = (inputs[17] * 10000)
69
-
    let x19_scaled = (inputs[18] * 10000)
70
-
    let x20_scaled = (inputs[19] * 10000)
71
-
    let x21_scaled = (inputs[20] * 10000)
72
-
    let x22_scaled = (inputs[21] * 10000)
73
-
    let x23_scaled = (inputs[22] * 10000)
74
-
    let scaled_inputs = [x1_scaled, x2_scaled, x3_scaled, x4_scaled, x5_scaled, x6_scaled, x7_scaled, x8_scaled, x9_scaled, x10_scaled, x11_scaled, x12_scaled, x13_scaled, x14_scaled, x15_scaled, x16_scaled, x17_scaled, x18_scaled, x19_scaled, x20_scaled, x21_scaled, x22_scaled, x23_scaled]
55
+
    let scaled_inputs = [x1_scaled, x2_scaled]
75
56
 
    let z1 = linear_forward_1(scaled_inputs, weights_layer_1, biases_layer_1)
76
-
    let a1 = relu_activation(z1, 15)
57
+
    let a1 = sigmoid_activation(z1, 2)
77
58
 
    let z2 = linear_forward_2(a1, weights_layer_2, biases_layer_2)
78
-
    let a2 = z2
59
+
    let a2 = sigmoid_activation(z2, 1)
79
60
 
    let result0 = a2[0]
80
-
    let result1 = a2[1]
81
61
 
    let debug_outputs = nil
82
-
    ([IntegerEntry("move_prediction_0", result0), IntegerEntry("move_prediction_1", result1)] ++ debug_outputs)
62
+
    ([IntegerEntry("move_prediction_0", result0)] ++ debug_outputs)
83
63
 
    }
84
64
 
85
65
 

github/deemru/w8io/873ac7e 
61.48 ms ◑