text
stringlengths 1
2.05k
|
|---|
t::new(655360, false),
FixedTrait::new(924057, false),
FixedTrait::new(14090240, false),
FixedTrait::new(3768, false),
FixedTrait::new(8388608, false),
FixedTrait::new(1880883, false),
FixedTrait::new(5065932, false),
FixedTrait::new(206438400, false),
FixedTrait::new(25, false),
FixedTrait::new(688128, false),
FixedTrait::new(924057, false),
FixedTrait::new(14155776, false),
FixedTrait::new(3768, false),
FixedTrait::new(8454144, false),
FixedTrait::new(1893990, false),
FixedTrait::new(5065932, false),
FixedTrait::new(204472320, false),
FixedTrait::new(50, false),
FixedTrait::new(681574, false),
FixedTrait::new(924057, false),
FixedTrait::new(14286848, false),
FixedTrait::new(3768, false),
FixedTrait::new(8585216, false),
FixedTrait::new(1900544, false),
FixedTrait::new(5072486, false),
FixedTrait::new(205127680, false),
FixedTrait::new(76, false),
FixedTrait::new(640942, false),
FixedTrait::new(924057, false),
FixedTrait::new(14352384, false),
FixedTrait::new(3768, false),
FixedTrait::new(8650752, false),
FixedTrait::new(1933312, false),
FixedTrait::new(5072486, false),
FixedTrait::new(209059840, false),
FixedTrait::new(100, false),
FixedTrait::new(747110, false),
FixedTrait::new(924057, false),
FixedTrait::new(14483456, false),
FixedTrait::new(3768, false),
FixedTrait::new(8716288, false),
FixedTrait::new(1939865, false),
FixedTrait::new(5072486, false),
FixedTrait::new(201195519, false),
FixedTrait::new(126, false),
FixedTrait::new(650117, false),
FixedTrait::new(98959 |
3, false),
FixedTrait::new(14614528, false),
FixedTrait::new(3768, false),
FixedTrait::new(8781824, false),
FixedTrait::new(1966080, false),
FixedTrait::new(5079040, false),
FixedTrait::new(209059840, false),
FixedTrait::new(152, false),
FixedTrait::new(645529, false),
FixedTrait::new(989593, false),
FixedTrait::new(14876672, false),
FixedTrait::new(3768, false),
FixedTrait::new(8978432, false),
FixedTrait::new(1979187, false),
FixedTrait::new(5085593, false),
FixedTrait::new(209715200, false),
FixedTrait::new(1, false),
FixedTrait::new(653393, false),
FixedTrait::new(1002700, false),
FixedTrait::new(14876672, false),
FixedTrait::new(3951, false),
FixedTrait::new(8978432, false),
FixedTrait::new(1959526, false),
FixedTrait::new(5111808, false),
FixedTrait::new(209059840, false),
FixedTrait::new(26, false),
FixedTrait::new(614072, false),
FixedTrait::new(1009254, false),
FixedTrait::new(15007744, false),
FixedTrait::new(3951, false),
FixedTrait::new(9043968, false),
FixedTrait::new(1926758, false),
FixedTrait::new(5157683, false),
FixedTrait::new(211025919, false),
FixedTrait::new(54, false),
FixedTrait::new(523632, false),
FixedTrait::new(1009254, false),
FixedTrait::new(15073280, false),
FixedTrait::new(3951, false),
FixedTrait::new(9043968, false),
FixedTrait::new(2011955, false),
FixedTrait::new(5203558, false),
FixedTrait::new(220856320, false),
FixedTrait::new(78, false),
FixedTrait::new(688128, false),
FixedTrait::new(1009254, false),
FixedTrait::new(15138816, false |
),
FixedTrait::new(3951, false),
FixedTrait::new(9109504, false),
FixedTrait::new(1861222, false),
FixedTrait::new(5360844, false),
FixedTrait::new(203816960, false),
FixedTrait::new(102, false),
FixedTrait::new(688128, false),
FixedTrait::new(1028915, false),
FixedTrait::new(15204352, false),
FixedTrait::new(3951, false),
FixedTrait::new(9109504, false),
FixedTrait::new(1861222, false),
FixedTrait::new(5367398, false),
FixedTrait::new(203816960, false),
FixedTrait::new(126, false),
FixedTrait::new(694681, false),
FixedTrait::new(1028915, false),
FixedTrait::new(15204352, false),
FixedTrait::new(3951, false),
FixedTrait::new(9109504, false),
FixedTrait::new(1861222, false),
FixedTrait::new(5367398, false),
FixedTrait::new(203161600, false),
FixedTrait::new(151, false),
FixedTrait::new(681574, false),
FixedTrait::new(1028915, false),
FixedTrait::new(15466496, false),
FixedTrait::new(3951, false),
FixedTrait::new(9371648, false),
FixedTrait::new(1848115, false),
FixedTrait::new(5452595, false),
FixedTrait::new(203161600, false),
FixedTrait::new(1, false),
FixedTrait::new(591790, false),
FixedTrait::new(1048576, false),
FixedTrait::new(15663104, false),
FixedTrait::new(4128, false),
FixedTrait::new(9568256, false),
FixedTrait::new(1985740, false),
FixedTrait::new(5485363, false),
FixedTrait::new(214302719, false),
FixedTrait::new(29, false),
FixedTrait::new(565575, false),
FixedTrait::new(1048576, false),
FixedTrait::new(15859712, false),
FixedTrait::new(4128, false), |
FixedTrait::new(9764864, false),
FixedTrait::new(2025062, false),
FixedTrait::new(5505024, false),
FixedTrait::new(217579519, false),
FixedTrait::new(57, false),
FixedTrait::new(681574, false),
FixedTrait::new(1048576, false),
FixedTrait::new(16187392, false),
FixedTrait::new(4128, false),
FixedTrait::new(9961472, false),
FixedTrait::new(1979187, false),
FixedTrait::new(5583667, false),
FixedTrait::new(207093760, false),
FixedTrait::new(83, false),
FixedTrait::new(547225, false),
FixedTrait::new(1048576, false),
FixedTrait::new(16580607, false),
FixedTrait::new(4128, false),
FixedTrait::new(10223616, false),
FixedTrait::new(1998848, false),
FixedTrait::new(5681971, false),
FixedTrait::new(218234879, false),
FixedTrait::new(110, false),
FixedTrait::new(753664, false),
FixedTrait::new(1048576, false),
FixedTrait::new(16777216, false),
FixedTrait::new(4128, false),
FixedTrait::new(10289152, false),
FixedTrait::new(1966080, false),
FixedTrait::new(5754060, false),
FixedTrait::new(201195519, false),
FixedTrait::new(135, false),
FixedTrait::new(747110, false),
FixedTrait::new(1048576, false),
FixedTrait::new(16842752, false),
FixedTrait::new(4128, false),
FixedTrait::new(10289152, false),
FixedTrait::new(1992294, false),
FixedTrait::new(5780275, false),
FixedTrait::new(202506239, false),
]
.span()
);
return tensor;
} |
use array::ArrayTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16Impl, FP16x16PartialEq};
use orion::operators::tensor::{Tensor, TensorTrait, FP16x16Tensor};
use orion::numbers::{FP16x16, FixedTrait};
fn aave_y_labels() -> Tensor<FP16x16> {
let tensor = TensorTrait::<
FP16x16
>::new(
shape: array![24].span(),
data: array![
FixedTrait::new(5072486, false),
FixedTrait::new(5072486, false),
FixedTrait::new(5079040, false),
FixedTrait::new(5085593, false),
FixedTrait::new(5111808, false),
FixedTrait::new(5157683, false),
FixedTrait::new(5203558, false),
FixedTrait::new(5360844, false),
FixedTrait::new(5367398, false),
FixedTrait::new(5367398, false),
FixedTrait::new(5452595, false),
FixedTrait::new(5485363, false),
FixedTrait::new(5505024, false),
FixedTrait::new(5583667, false),
FixedTrait::new(5681971, false),
FixedTrait::new(5754060, false),
FixedTrait::new(5780275, false),
FixedTrait::new(5852364, false),
FixedTrait::new(5891686, false),
FixedTrait::new(5963776, false),
FixedTrait::new(6035865, false),
FixedTrait::new(6134169, false),
FixedTrait::new(6153830, false),
FixedTrait::new(6180044, false),
]
.span()
);
return tensor;
}
|
mod boston_x_features;
mod boston_y_labels;
|
use array::ArrayTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16Impl, FP16x16PartialEq};
use orion::operators::tensor::{Tensor, TensorTrait, FP16x16Tensor};
use orion::numbers::{FP16x16, FixedTrait};
fn boston_x_features() -> Tensor<FP16x16> {
let tensor = TensorTrait::<
FP16x16
>::new(
shape: array![50, 11].span(),
data: array![
FixedTrait::new(26719, false),
FixedTrait::new(0, false),
FixedTrait::new(406323, false),
FixedTrait::new(65536, false),
FixedTrait::new(33226, false),
FixedTrait::new(403963, false),
FixedTrait::new(5983436, false),
FixedTrait::new(199753, false),
FixedTrait::new(524288, false),
FixedTrait::new(20119552, false),
FixedTrait::new(1140326, false),
FixedTrait::new(17588, false),
FixedTrait::new(0, false),
FixedTrait::new(635043, false),
FixedTrait::new(0, false),
FixedTrait::new(38338, false),
FixedTrait::new(379715, false),
FixedTrait::new(4626841, false),
FixedTrait::new(189575, false),
FixedTrait::new(393216, false),
FixedTrait::new(25624576, false),
FixedTrait::new(1258291, false),
FixedTrait::new(3512, false),
FixedTrait::new(1376256, false),
FixedTrait::new(369623, false),
FixedTrait::new(0, false),
FixedTrait::new(28770, false),
FixedTrait::new(426704, false),
FixedTrait::new(1382809, false),
FixedTrait::new(446608, false),
FixedTrait::new(262144, false),
FixedTrait::new(15925248, false),
FixedTrait::new(1101004, false),
FixedTrait::new(731407, false),
FixedTrait::new(0, false),
FixedTrait::new(1186201, false),
FixedTrait::new(0, false),
FixedTrait::new(48496, false), |
FixedTrait::new(434438, false),
FixedTrait::new(6199705, false),
FixedTrait::new(139244, false),
FixedTrait::new(1572864, false),
FixedTrait::new(43646976, false),
FixedTrait::new(1323827, false),
FixedTrait::new(151643, false),
FixedTrait::new(0, false),
FixedTrait::new(1283194, false),
FixedTrait::new(0, false),
FixedTrait::new(39649, false),
FixedTrait::new(385351, false),
FixedTrait::new(6376652, false),
FixedTrait::new(156545, false),
FixedTrait::new(327680, false),
FixedTrait::new(26411008, false),
FixedTrait::new(963379, false),
FixedTrait::new(637283, false),
FixedTrait::new(0, false),
FixedTrait::new(1186201, false),
FixedTrait::new(0, false),
FixedTrait::new(48496, false),
FixedTrait::new(419823, false),
FixedTrait::new(6370099, false),
FixedTrait::new(135338, false),
FixedTrait::new(1572864, false),
FixedTrait::new(43646976, false),
FixedTrait::new(1323827, false),
FixedTrait::new(6860, false),
FixedTrait::new(2621440, false),
FixedTrait::new(420085, false),
FixedTrait::new(65536, false),
FixedTrait::new(29294, false),
FixedTrait::new(476250, false),
FixedTrait::new(3211264, false),
FixedTrait::new(313733, false),
FixedTrait::new(262144, false),
FixedTrait::new(16646144, false),
FixedTrait::new(1153433, false),
FixedTrait::new(1598672, false),
FixedTrait::new(0, false),
FixedTrait::new(1186201, false),
FixedTrait::new(0, false),
FixedTrait::new(45875, false),
FixedTrait::new(304873, false),
FixedTrait::new(6553600, false),
FixedTrait::new(96154, false), |
FixedTrait::new(1572864, false),
FixedTrait::new(43646976, false),
FixedTrait::new(1323827, false),
FixedTrait::new(264661, false),
FixedTrait::new(0, false),
FixedTrait::new(1186201, false),
FixedTrait::new(0, false),
FixedTrait::new(34865, false),
FixedTrait::new(408223, false),
FixedTrait::new(5944115, false),
FixedTrait::new(203115, false),
FixedTrait::new(1572864, false),
FixedTrait::new(43646976, false),
FixedTrait::new(1323827, false),
FixedTrait::new(10624, false),
FixedTrait::new(1310720, false),
FixedTrait::new(456130, false),
FixedTrait::new(0, false),
FixedTrait::new(30408, false),
FixedTrait::new(408944, false),
FixedTrait::new(1068236, false),
FixedTrait::new(290258, false),
FixedTrait::new(196608, false),
FixedTrait::new(14614528, false),
FixedTrait::new(1218969, false),
FixedTrait::new(6768, false),
FixedTrait::new(1638400, false),
FixedTrait::new(336199, false),
FixedTrait::new(0, false),
FixedTrait::new(29687, false),
FixedTrait::new(388431, false),
FixedTrait::new(3093299, false),
FixedTrait::new(454295, false),
FixedTrait::new(524288, false),
FixedTrait::new(18612224, false),
FixedTrait::new(1291059, false),
FixedTrait::new(40077, false),
FixedTrait::new(1310720, false),
FixedTrait::new(260177, false),
FixedTrait::new(0, false),
FixedTrait::new(42401, false),
FixedTrait::new(570425, false),
FixedTrait::new(5695078, false),
FixedTrait::new(118030, false),
FixedTrait::new(327680, false),
FixedTrait::new(17301504, false),
FixedTrait::new(8519 |
68, false),
FixedTrait::new(527944, false),
FixedTrait::new(0, false),
FixedTrait::new(1186201, false),
FixedTrait::new(0, false),
FixedTrait::new(38273, false),
FixedTrait::new(355663, false),
FixedTrait::new(6252134, false),
FixedTrait::new(159239, false),
FixedTrait::new(1572864, false),
FixedTrait::new(43646976, false),
FixedTrait::new(1323827, false),
FixedTrait::new(14030, false),
FixedTrait::new(1441792, false),
FixedTrait::new(384040, false),
FixedTrait::new(0, false),
FixedTrait::new(28246, false),
FixedTrait::new(421920, false),
FixedTrait::new(583270, false),
FixedTrait::new(484750, false),
FixedTrait::new(458752, false),
FixedTrait::new(21626880, false),
FixedTrait::new(1251737, false),
FixedTrait::new(22353, false),
FixedTrait::new(0, false),
FixedTrait::new(483655, false),
FixedTrait::new(0, false),
FixedTrait::new(32309, false),
FixedTrait::new(420413, false),
FixedTrait::new(2627993, false),
FixedTrait::new(309402, false),
FixedTrait::new(327680, false),
FixedTrait::new(18808832, false),
FixedTrait::new(1284505, false),
FixedTrait::new(51800, false),
FixedTrait::new(0, false),
FixedTrait::new(648806, false),
FixedTrait::new(0, false),
FixedTrait::new(35651, false),
FixedTrait::new(401211, false),
FixedTrait::new(3460300, false),
FixedTrait::new(173034, false),
FixedTrait::new(262144, false),
FixedTrait::new(19922944, false),
FixedTrait::new(1205862, false),
FixedTrait::new(1998, false),
FixedTrait::new(3604480, false),
FixedTrait::new(247726, f |
alse),
FixedTrait::new(0, false),
FixedTrait::new(31719, false),
FixedTrait::new(450494, false),
FixedTrait::new(1841561, false),
FixedTrait::new(423716, false),
FixedTrait::new(327680, false),
FixedTrait::new(24248320, false),
FixedTrait::new(1153433, false),
FixedTrait::new(22898, false),
FixedTrait::new(0, false),
FixedTrait::new(648806, false),
FixedTrait::new(0, false),
FixedTrait::new(35651, false),
FixedTrait::new(391380, false),
FixedTrait::new(5026611, false),
FixedTrait::new(203325, false),
FixedTrait::new(262144, false),
FixedTrait::new(19922944, false),
FixedTrait::new(1205862, false),
FixedTrait::new(24195, false),
FixedTrait::new(0, false),
FixedTrait::new(648806, false),
FixedTrait::new(0, false),
FixedTrait::new(35651, false),
FixedTrait::new(430374, false),
FixedTrait::new(5721292, false),
FixedTrait::new(236080, false),
FixedTrait::new(262144, false),
FixedTrait::new(19922944, false),
FixedTrait::new(1205862, false),
FixedTrait::new(623485, false),
FixedTrait::new(0, false),
FixedTrait::new(1186201, false),
FixedTrait::new(0, false),
FixedTrait::new(46727, false),
FixedTrait::new(440926, false),
FixedTrait::new(6166937, false),
FixedTrait::new(163584, false),
FixedTrait::new(1572864, false),
FixedTrait::new(43646976, false),
FixedTrait::new(1323827, false),
FixedTrait::new(52606, false),
FixedTrait::new(0, false),
FixedTrait::new(533463, false),
FixedTrait::new(0, false),
FixedTrait::new(35258, false),
FixedTrait::new(357564, false), |
FixedTrait::new(2398617, false),
FixedTrait::new(248807, false),
FixedTrait::new(262144, false),
FixedTrait::new(20119552, false),
FixedTrait::new(1376256, false),
FixedTrait::new(3709, false),
FixedTrait::new(0, false),
FixedTrait::new(223477, false),
FixedTrait::new(0, false),
FixedTrait::new(32047, false),
FixedTrait::new(459210, false),
FixedTrait::new(5655756, false),
FixedTrait::new(224244, false),
FixedTrait::new(131072, false),
FixedTrait::new(17694720, false),
FixedTrait::new(1166540, false),
FixedTrait::new(28554, false),
FixedTrait::new(0, false),
FixedTrait::new(694026, false),
FixedTrait::new(65536, false),
FixedTrait::new(32047, false),
FixedTrait::new(350224, false),
FixedTrait::new(6553600, false),
FixedTrait::new(253952, false),
FixedTrait::new(262144, false),
FixedTrait::new(18153472, false),
FixedTrait::new(1218969, false),
FixedTrait::new(34087, false),
FixedTrait::new(1310720, false),
FixedTrait::new(260177, false),
FixedTrait::new(0, false),
FixedTrait::new(42401, false),
FixedTrait::new(550371, false),
FixedTrait::new(5996544, false),
FixedTrait::new(149979, false),
FixedTrait::new(327680, false),
FixedTrait::new(17301504, false),
FixedTrait::new(851968, false),
FixedTrait::new(802632, false),
FixedTrait::new(0, false),
FixedTrait::new(1186201, false),
FixedTrait::new(0, false),
FixedTrait::new(38273, false),
FixedTrait::new(382533, false),
FixedTrait::new(3912499, false),
FixedTrait::new(130914, false),
FixedTrait::new(1572864, false), |
FixedTrait::new(43646976, false),
FixedTrait::new(1323827, false),
FixedTrait::new(17654, false),
FixedTrait::new(0, false),
FixedTrait::new(648806, false),
FixedTrait::new(0, false),
FixedTrait::new(35651, false),
FixedTrait::new(410648, false),
FixedTrait::new(5426380, false),
FixedTrait::new(213830, false),
FixedTrait::new(262144, false),
FixedTrait::new(19922944, false),
FixedTrait::new(1205862, false),
FixedTrait::new(2988, false),
FixedTrait::new(0, false),
FixedTrait::new(910295, false),
FixedTrait::new(65536, false),
FixedTrait::new(36044, false),
FixedTrait::new(385875, false),
FixedTrait::new(3670016, false),
FixedTrait::new(203954, false),
FixedTrait::new(327680, false),
FixedTrait::new(18087936, false),
FixedTrait::new(1074790, false),
FixedTrait::new(3787, false),
FixedTrait::new(0, false),
FixedTrait::new(161218, false),
FixedTrait::new(0, false),
FixedTrait::new(31981, false),
FixedTrait::new(457441, false),
FixedTrait::new(3827302, false),
FixedTrait::new(185401, false),
FixedTrait::new(196608, false),
FixedTrait::new(12648448, false),
FixedTrait::new(1166540, false),
FixedTrait::new(54084, false),
FixedTrait::new(1310720, false),
FixedTrait::new(260177, false),
FixedTrait::new(0, false),
FixedTrait::new(42401, false),
FixedTrait::new(480182, false),
FixedTrait::new(6193152, false),
FixedTrait::new(136236, false),
FixedTrait::new(327680, false),
FixedTrait::new(17301504, false),
FixedTrait::new(851968, false),
FixedTrait::new(227690, false), |
FixedTrait::new(0, false),
FixedTrait::new(1186201, false),
FixedTrait::new(65536, false),
FixedTrait::new(47054, false),
FixedTrait::new(575406, false),
FixedTrait::new(5432934, false),
FixedTrait::new(124826, false),
FixedTrait::new(1572864, false),
FixedTrait::new(43646976, false),
FixedTrait::new(1323827, false),
FixedTrait::new(35685, false),
FixedTrait::new(0, false),
FixedTrait::new(1434583, false),
FixedTrait::new(0, false),
FixedTrait::new(40894, false),
FixedTrait::new(403111, false),
FixedTrait::new(6415974, false),
FixedTrait::new(109359, false),
FixedTrait::new(262144, false),
FixedTrait::new(28639232, false),
FixedTrait::new(1389363, false),
FixedTrait::new(9209, false),
FixedTrait::new(0, false),
FixedTrait::new(694026, false),
FixedTrait::new(0, false),
FixedTrait::new(32047, false),
FixedTrait::new(417792, false),
FixedTrait::new(2116812, false),
FixedTrait::new(258565, false),
FixedTrait::new(262144, false),
FixedTrait::new(18153472, false),
FixedTrait::new(1218969, false),
FixedTrait::new(3069, false),
FixedTrait::new(0, false),
FixedTrait::new(223477, false),
FixedTrait::new(0, false),
FixedTrait::new(32047, false),
FixedTrait::new(420544, false),
FixedTrait::new(4331929, false),
FixedTrait::new(202656, false),
FixedTrait::new(131072, false),
FixedTrait::new(17694720, false),
FixedTrait::new(1166540, false),
FixedTrait::new(4016, false),
FixedTrait::new(1310720, false),
FixedTrait::new(218234, false),
FixedTrait::new(65536, false),
FixedT |
rait::new(29025, false),
FixedTrait::new(501022, false),
FixedTrait::new(3257139, false),
FixedTrait::new(341567, false),
FixedTrait::new(327680, false),
FixedTrait::new(14155776, false),
FixedTrait::new(976486, false),
FixedTrait::new(63974, false),
FixedTrait::new(0, false),
FixedTrait::new(1434583, false),
FixedTrait::new(0, false),
FixedTrait::new(40894, false),
FixedTrait::new(377290, false),
FixedTrait::new(6448742, false),
FixedTrait::new(153747, false),
FixedTrait::new(262144, false),
FixedTrait::new(28639232, false),
FixedTrait::new(1389363, false),
FixedTrait::new(14556, false),
FixedTrait::new(0, false),
FixedTrait::new(656015, false),
FixedTrait::new(0, false),
FixedTrait::new(35848, false),
FixedTrait::new(399245, false),
FixedTrait::new(6252134, false),
FixedTrait::new(166985, false),
FixedTrait::new(393216, false),
FixedTrait::new(28311552, false),
FixedTrait::new(1166540, false),
FixedTrait::new(11358, false),
FixedTrait::new(0, false),
FixedTrait::new(635043, false),
FixedTrait::new(0, false),
FixedTrait::new(38338, false),
FixedTrait::new(374013, false),
FixedTrait::new(3538944, false),
FixedTrait::new(156087, false),
FixedTrait::new(393216, false),
FixedTrait::new(25624576, false),
FixedTrait::new(1258291, false),
FixedTrait::new(3758, false),
FixedTrait::new(0, false),
FixedTrait::new(294256, false),
FixedTrait::new(0, false),
FixedTrait::new(29425, false),
FixedTrait::new(434503, false),
FixedTrait::new(3676569, false),
FixedTrait::new(290 |
829, false),
FixedTrait::new(196608, false),
FixedTrait::new(16187392, false),
FixedTrait::new(1212416, false),
FixedTrait::new(11143, false),
FixedTrait::new(819200, false),
FixedTrait::new(515768, false),
FixedTrait::new(0, false),
FixedTrait::new(34340, false),
FixedTrait::new(393478, false),
FixedTrait::new(5629542, false),
FixedTrait::new(432019, false),
FixedTrait::new(327680, false),
FixedTrait::new(20381696, false),
FixedTrait::new(996147, false),
FixedTrait::new(2121, false),
FixedTrait::new(0, false),
FixedTrait::new(142868, false),
FixedTrait::new(0, false),
FixedTrait::new(30015, false),
FixedTrait::new(458620, false),
FixedTrait::new(3001548, false),
FixedTrait::new(397292, false),
FixedTrait::new(196608, false),
FixedTrait::new(14548992, false),
FixedTrait::new(1225523, false),
FixedTrait::new(10443, false),
FixedTrait::new(0, false),
FixedTrait::new(452853, false),
FixedTrait::new(0, false),
FixedTrait::new(29360, false),
FixedTrait::new(407044, false),
FixedTrait::new(425984, false),
FixedTrait::new(374924, false),
FixedTrait::new(196608, false),
FixedTrait::new(15269888, false),
FixedTrait::new(1173094, false),
FixedTrait::new(3057, false),
FixedTrait::new(5242880, false),
FixedTrait::new(99614, false),
FixedTrait::new(0, false),
FixedTrait::new(26476, false),
FixedTrait::new(465764, false),
FixedTrait::new(2398617, false),
FixedTrait::new(479002, false),
FixedTrait::new(131072, false),
FixedTrait::new(21561344, false),
FixedTrait::new(825753, |
false),
FixedTrait::new(2325, false),
FixedTrait::new(5242880, false),
FixedTrait::new(238551, false),
FixedTrait::new(0, false),
FixedTrait::new(25690, false),
FixedTrait::new(385089, false),
FixedTrait::new(1251737, false),
FixedTrait::new(604261, false),
FixedTrait::new(65536, false),
FixedTrait::new(20643840, false),
FixedTrait::new(1074790, false),
FixedTrait::new(4601, false),
FixedTrait::new(0, false),
FixedTrait::new(265420, false),
FixedTrait::new(0, false),
FixedTrait::new(33423, false),
FixedTrait::new(394526, false),
FixedTrait::new(3093299, false),
FixedTrait::new(232973, false),
FixedTrait::new(327680, false),
FixedTrait::new(19398656, false),
FixedTrait::new(1087897, false),
FixedTrait::new(2816, false),
FixedTrait::new(3440640, false),
FixedTrait::new(348651, false),
FixedTrait::new(0, false),
FixedTrait::new(26542, false),
FixedTrait::new(430243, false),
FixedTrait::new(1500774, false),
FixedTrait::new(479540, false),
FixedTrait::new(393216, false),
FixedTrait::new(19202048, false),
FixedTrait::new(1087897, false),
FixedTrait::new(90963, false),
FixedTrait::new(0, false),
FixedTrait::new(533463, false),
FixedTrait::new(0, false),
FixedTrait::new(35258, false),
FixedTrait::new(389939, false),
FixedTrait::new(5373952, false),
FixedTrait::new(261488, false),
FixedTrait::new(262144, false),
FixedTrait::new(20119552, false),
FixedTrait::new(1376256, false),
FixedTrait::new(12499, false),
FixedTrait::new(1441792, false),
FixedTrait::new(384040, fal |
se),
FixedTrait::new(0, false),
FixedTrait::new(28246, false),
FixedTrait::new(440270, false),
FixedTrait::new(1146880, false),
FixedTrait::new(512917, false),
FixedTrait::new(458752, false),
FixedTrait::new(21626880, false),
FixedTrait::new(1251737, false),
FixedTrait::new(12805, false),
FixedTrait::new(0, false),
FixedTrait::new(708444, false),
FixedTrait::new(0, false),
FixedTrait::new(27066, false),
FixedTrait::new(409272, false),
FixedTrait::new(406323, false),
FixedTrait::new(346508, false),
FixedTrait::new(262144, false),
FixedTrait::new(19988480, false),
FixedTrait::new(1258291, false),
FixedTrait::new(758769, false),
FixedTrait::new(0, false),
FixedTrait::new(1186201, false),
FixedTrait::new(0, false),
FixedTrait::new(45875, false),
FixedTrait::new(330039, false),
FixedTrait::new(6356992, false),
FixedTrait::new(115998, false),
FixedTrait::new(1572864, false),
FixedTrait::new(43646976, false),
FixedTrait::new(1323827, false),
FixedTrait::new(2369, false),
FixedTrait::new(5242880, false),
FixedTrait::new(324403, false),
FixedTrait::new(0, false),
FixedTrait::new(26935, false),
FixedTrait::new(434503, false),
FixedTrait::new(1533542, false),
FixedTrait::new(335328, false),
FixedTrait::new(262144, false),
FixedTrait::new(16056320, false),
FixedTrait::new(1258291, false),
]
.span()
);
return tensor;
} |
use array::ArrayTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16Impl, FP16x16PartialEq};
use orion::operators::tensor::{Tensor, TensorTrait, FP16x16Tensor};
use orion::numbers::{FP16x16, FixedTrait};
fn boston_y_labels() -> Tensor<FP16x16> {
let tensor = TensorTrait::<
FP16x16
>::new(
shape: array![50].span(),
data: array![
FixedTrait::new(1422131, false),
FixedTrait::new(1199308, false),
FixedTrait::new(1638400, false),
FixedTrait::new(878182, false),
FixedTrait::new(1251737, false),
FixedTrait::new(1120665, false),
FixedTrait::new(2175795, false),
FixedTrait::new(688128, false),
FixedTrait::new(1284505, false),
FixedTrait::new(1651507, false),
FixedTrait::new(1284505, false),
FixedTrait::new(3276800, false),
FixedTrait::new(904396, false),
FixedTrait::new(1625292, false),
FixedTrait::new(1638400, false),
FixedTrait::new(1448345, false),
FixedTrait::new(2044723, false),
FixedTrait::new(1330380, false),
FixedTrait::new(1559756, false),
FixedTrait::new(976486, false),
FixedTrait::new(1323827, false),
FixedTrait::new(1546649, false),
FixedTrait::new(1310720, false),
FixedTrait::new(3198156, false),
FixedTrait::new(668467, false),
FixedTrait::new(1415577, false),
FixedTrait::new(1526988, false),
FixedTrait::new(2437939, false),
FixedTrait::new(2031616, false),
FixedTrait::new(1435238, false),
FixedTrait::new(1166540, false),
FixedTrait::new(1841561, false),
FixedTrait::new(1481113, false),
FixedTrait::new(3014656, false),
FixedTrait::new(1022361, false),
FixedTrait::new(1225523, false),
FixedTrait::new(1428684, false |
),
FixedTrait::new(1743257, false),
FixedTrait::new(1238630, false),
FixedTrait::new(2188902, false),
FixedTrait::new(1618739, false),
FixedTrait::new(1985740, false),
FixedTrait::new(1369702, false),
FixedTrait::new(1520435, false),
FixedTrait::new(1625292, false),
FixedTrait::new(865075, false),
FixedTrait::new(1717043, false),
FixedTrait::new(1533542, false),
FixedTrait::new(635699, false),
FixedTrait::new(1828454, false),
]
.span()
);
return tensor;
} |
mod feature_data;
mod label_data;
|
use array::ArrayTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16Impl, FP16x16PartialEq};
use orion::operators::tensor::{Tensor, TensorTrait, FP16x16Tensor};
use orion::numbers::{FP16x16, FixedTrait};
fn x_feature_data() -> Tensor<FP16x16> {
let tensor = TensorTrait::<
FP16x16
>::new(
shape: array![50].span(),
data: array![
FixedTrait::new(19671, false),
FixedTrait::new(23085, true),
FixedTrait::new(74876, true),
FixedTrait::new(22894, true),
FixedTrait::new(13690, true),
FixedTrait::new(38444, false),
FixedTrait::new(54983, false),
FixedTrait::new(61020, false),
FixedTrait::new(18716, false),
FixedTrait::new(58008, false),
FixedTrait::new(49440, true),
FixedTrait::new(82107, false),
FixedTrait::new(33615, false),
FixedTrait::new(19535, true),
FixedTrait::new(32015, false),
FixedTrait::new(4952, true),
FixedTrait::new(74162, false),
FixedTrait::new(99602, false),
FixedTrait::new(143233, false),
FixedTrait::new(91520, true),
FixedTrait::new(94641, true),
FixedTrait::new(33060, true),
FixedTrait::new(10488, false),
FixedTrait::new(57420, false),
FixedTrait::new(20685, false),
FixedTrait::new(132526, true),
FixedTrait::new(20067, true),
FixedTrait::new(54262, false),
FixedTrait::new(15079, false),
FixedTrait::new(49939, false),
FixedTrait::new(14570, true),
FixedTrait::new(13156, true),
FixedTrait::new(12226, false),
FixedTrait::new(26873, false),
FixedTrait::new(12995, false),
FixedTrait::new(7799, false),
FixedTrait::new(43952, true),
FixedTrait::new(24744, false),
FixedTrait::new(7983, false |
),
FixedTrait::new(74021, false),
FixedTrait::new(78572, false),
FixedTrait::new(12134, false),
FixedTrait::new(24594, true),
FixedTrait::new(41859, true),
FixedTrait::new(27754, false),
FixedTrait::new(5068, false),
FixedTrait::new(22534, true),
FixedTrait::new(2857, false),
FixedTrait::new(40632, true),
FixedTrait::new(45746, false),
]
.span()
);
return tensor;
} |
use array::ArrayTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16Impl, FP16x16PartialEq};
use orion::operators::tensor::{Tensor, TensorTrait, FP16x16Tensor};
use orion::numbers::{FP16x16, FixedTrait};
fn y_label_data() -> Tensor<FP16x16> {
let tensor = TensorTrait::<
FP16x16
>::new(
shape: array![50].span(),
data: array![
FixedTrait::new(6817428, false),
FixedTrait::new(6328827, false),
FixedTrait::new(5919977, false),
FixedTrait::new(6300125, false),
FixedTrait::new(6500794, false),
FixedTrait::new(6710325, false),
FixedTrait::new(7107816, false),
FixedTrait::new(6991879, false),
FixedTrait::new(6724238, false),
FixedTrait::new(7001326, false),
FixedTrait::new(6253898, false),
FixedTrait::new(7075450, false),
FixedTrait::new(6801393, false),
FixedTrait::new(6372144, false),
FixedTrait::new(6884026, false),
FixedTrait::new(6441896, false),
FixedTrait::new(7135599, false),
FixedTrait::new(7292890, false),
FixedTrait::new(7702237, false),
FixedTrait::new(5859629, false),
FixedTrait::new(5724338, false),
FixedTrait::new(6364135, false),
FixedTrait::new(6696592, false),
FixedTrait::new(7045896, false),
FixedTrait::new(6778122, false),
FixedTrait::new(5448575, false),
FixedTrait::new(6385007, false),
FixedTrait::new(6926370, false),
FixedTrait::new(6656679, false),
FixedTrait::new(6987870, false),
FixedTrait::new(6391707, false),
FixedTrait::new(6422343, false),
FixedTrait::new(6606377, false),
FixedTrait::new(6713193, false),
FixedTrait::new(6613575, false),
FixedTrait::new(6615164, false),
FixedTrait::new(6128755, fal |
se),
FixedTrait::new(6766914, false),
FixedTrait::new(6726246, false),
FixedTrait::new(7194405, false),
FixedTrait::new(7169606, false),
FixedTrait::new(6592503, false),
FixedTrait::new(6307876, false),
FixedTrait::new(6329638, false),
FixedTrait::new(6778962, false),
FixedTrait::new(6552402, false),
FixedTrait::new(6385833, false),
FixedTrait::new(6714099, false),
FixedTrait::new(6236415, false),
FixedTrait::new(6960018, false),
]
.span()
);
return tensor;
} |
mod user_inputs_boston_data;
mod aave_weth_revenue_data_input;
|
use array::ArrayTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16Impl, FP16x16PartialEq};
use orion::operators::tensor::{Tensor, TensorTrait, FP16x16Tensor};
use orion::numbers::{FP16x16, FixedTrait};
fn aave_weth_revenue_data_input() -> Tensor<FP16x16> {
let tensor = TensorTrait::<
FP16x16
>::new(
shape: array![7, 9].span(),
data: array![
FixedTrait::new(160, false),
FixedTrait::new(786432, false),
FixedTrait::new(1048576, false),
FixedTrait::new(16973824, false),
FixedTrait::new(4128, false),
FixedTrait::new(10354688, false),
FixedTrait::new(1952972, false),
FixedTrait::new(5852364, false),
FixedTrait::new(198574079, false),
FixedTrait::new(185, false),
FixedTrait::new(681574, false),
FixedTrait::new(1048576, false),
FixedTrait::new(17170432, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1959526, false),
FixedTrait::new(5891686, false),
FixedTrait::new(207093760, false),
FixedTrait::new(211, false),
FixedTrait::new(688128, false),
FixedTrait::new(1055129, false),
FixedTrait::new(17301504, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1952972, false),
FixedTrait::new(5963776, false),
FixedTrait::new(206438400, false),
FixedTrait::new(236, false),
FixedTrait::new(707788, false),
FixedTrait::new(1055129, false),
FixedTrait::new(17367040, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1907097, false),
FixedTrait::new(6035865, false),
FixedTrait::new(203161600, false),
FixedTrait::new(261, false |
),
FixedTrait::new(792985, false),
FixedTrait::new(1061683, false),
FixedTrait::new(17432576, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1880883, false),
FixedTrait::new(6134169, false),
FixedTrait::new(195952639, false),
FixedTrait::new(285, false),
FixedTrait::new(792985, false),
FixedTrait::new(1061683, false),
FixedTrait::new(17432576, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1880883, false),
FixedTrait::new(6153830, false),
FixedTrait::new(195952639, false),
FixedTrait::new(308, false),
FixedTrait::new(792985, false),
FixedTrait::new(1061683, false),
FixedTrait::new(17498112, false),
FixedTrait::new(4128, false),
FixedTrait::new(10420224, false),
FixedTrait::new(1887436, false),
FixedTrait::new(6180044, false),
FixedTrait::new(196607999, false),
]
.span()
);
return tensor;
} |
use array::ArrayTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16Impl, FP16x16PartialEq};
use orion::operators::tensor::{Tensor, TensorTrait, FP16x16Tensor};
use orion::numbers::{FP16x16, FixedTrait};
fn user_input_boston_housing() -> Tensor<FP16x16> {
let tensor = TensorTrait::<
FP16x16
>::new(
shape: array![11].span(),
data: array![
FixedTrait::new(26719, false),
FixedTrait::new(0, false),
FixedTrait::new(406323, false),
FixedTrait::new(65536, false),
FixedTrait::new(33226, false),
FixedTrait::new(403963, false),
FixedTrait::new(5983436, false),
FixedTrait::new(199753, false),
FixedTrait::new(524288, false),
FixedTrait::new(20119552, false),
FixedTrait::new(1140326, false),
]
.span()
);
return tensor;
}
|
use debug::PrintTrait;
use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{
Tensor, TensorTrait, FP16x16Tensor, U32Tensor, U32TensorAdd, FP16x16TensorSub, FP16x16TensorAdd,
FP16x16TensorDiv, FP16x16TensorMul
};
use orion::numbers::{FP16x16, FixedTrait};
fn get_tensor_data_by_row(tensor_data: Tensor<FP16x16>, row_index: u32,) -> Tensor<FP16x16> {
let column_len = *tensor_data.shape.at(1);
let mut result = ArrayTrait::<FP16x16>::new();
let mut i: u32 = 0;
loop {
if i >= column_len {
break ();
}
result.append(tensor_data.at(indices: array![row_index, i].span()));
i += 1;
};
let resultant_tensor = TensorTrait::<
FP16x16
>::new(array![column_len].span(), data: result.span());
return resultant_tensor;
}
fn transpose_tensor(tensor_data: Tensor<FP16x16>) -> Tensor<FP16x16> {
let tensor_transposed = tensor_data.transpose(axes: array![1, 0].span());
return tensor_transposed;
}
fn calculate_mean(tensor_data: Tensor<FP16x16>) -> FP16x16 {
let tensor_size = FixedTrait::<FP16x16>::new_unscaled(tensor_data.data.len(), false);
let cumulated_sum = tensor_data.cumsum(0, Option::None(()), Option::None(()));
let sum_result = cumulated_sum.data[tensor_data.data.len() - 1];
let mean = *sum_result / tensor_size;
return mean;
}
fn calculate_r_score(Y_values: Tensor<FP16x16>, Y_pred_values: Tensor<FP16x16>) -> FP16x16 {
let mut Y_values_ = Y_values;
let mean_y_value = calculate_mean(Y_values);
let mut squared_diff_shape = array::ArrayTrait::new();
squared_diff_shape.append(Y_values.data.len());
let mut squared_diff_vals = array::ArrayTrait::new();
let mut squared_mean_diff_shape = array::ArrayTrait::new();
squared_mean_diff_shape.append(Y_values.data.len());
let mut squared_mean_diff_vals = array::ArrayTrait::new();
let mut i: u32 = 0;
loop {
match Y_values_.data.pop_front() {
Option::Some(y_value) => { |
let diff_pred = *y_value - *Y_pred_values.data.at(i);
let squared_diff = diff_pred * diff_pred;
squared_diff_vals.append(squared_diff);
let diff_mean = *y_value - mean_y_value;
let squared_mean_diff = diff_mean * diff_mean;
squared_mean_diff_vals.append(squared_mean_diff);
i += 1;
},
Option::None(_) => { break; }
}
};
let squared_diff_tensor = TensorTrait::<
FP16x16
>::new(squared_diff_shape.span(), squared_diff_vals.span());
let squared_mean_diff_tensor = TensorTrait::<
FP16x16
>::new(squared_mean_diff_shape.span(), squared_mean_diff_vals.span());
let sum_squared_diff = squared_diff_tensor.cumsum(0, Option::None(()), Option::None(()));
let sum_squared_mean_diff = squared_mean_diff_tensor
.cumsum(0, Option::None(()), Option::None(()));
let r_score = FixedTrait::new_unscaled(1, false)
- *sum_squared_diff.data.at(Y_values.data.len() - 1)
/ *sum_squared_mean_diff.data.at(Y_values.data.len() - 1);
return r_score;
}
fn normalize_user_x_inputs(
x_inputs: Tensor<FP16x16>, original_x_values: Tensor<FP16x16>
) -> Tensor<FP16x16> {
let mut x_inputs_normalized = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
let mut x_min = ArrayTrait::<FP16x16>::new();
let mut x_max = ArrayTrait::<FP16x16>::new();
let mut x_range = ArrayTrait::<FP16x16>::new();
let mut result = ArrayTrait::<FP16x16>::new();
if original_x_values.shape.len() > 1 {
let transposed_tensor = original_x_values.transpose(axes: array![1, 0].span());
let data_len = *transposed_tensor.shape.at(0);
let mut i: u32 = 0;
loop {
if i >= data_len {
break ();
}
let mut transposed_tensor_row = get_tensor_data_by_row(transposed_tensor, i);
x_min.append(transposed_ |
tensor_row.min_in_tensor());
x_max.append(transposed_tensor_row.max_in_tensor());
x_range
.append(
transposed_tensor_row.max_in_tensor() - transposed_tensor_row.min_in_tensor()
);
i += 1;
};
let mut x_min_tensor = TensorTrait::new(shape: array![data_len].span(), data: x_min.span());
let mut x_max_tensor = TensorTrait::new(shape: array![data_len].span(), data: x_max.span());
let mut x_range_tensor = TensorTrait::new(
shape: array![data_len].span(), data: x_range.span()
);
if x_inputs.shape.len() > 1 {
let mut j: u32 = 0;
loop {
if j >= *x_inputs.shape.at(0) {
break ();
};
let mut row_data = get_tensor_data_by_row(x_inputs, j);
let mut norm_row_data = (row_data - x_min_tensor) / x_range_tensor;
let mut k: u32 = 0;
loop {
if k >= norm_row_data.data.len() {
break ();
};
result.append(*norm_row_data.data.at(k));
k += 1;
};
j += 1;
};
x_inputs_normalized =
TensorTrait::<
FP16x16
>::new(
array![*x_inputs.shape.at(0), *x_inputs.shape.at(1)].span(), data: result.span()
);
};
if x_inputs.shape.len() == 1 {
x_inputs_normalized = (x_inputs - x_min_tensor) / x_range_tensor;
};
}
if original_x_values.shape.len() == 1 {
let mut x_min_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![original_x_values.min_in_tensor()].span());
let mut x_max_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![original_x_values.max_in_tensor()].span() |
);
let mut x_range_tensor = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(),
data: array![original_x_values.max_in_tensor() - original_x_values.min_in_tensor()]
.span()
);
let mut diff = ((x_inputs - x_min_tensor));
x_inputs_normalized = ((x_inputs - x_min_tensor)) / x_range_tensor;
};
return x_inputs_normalized;
}
fn rescale_predictions(
prediction_result: Tensor<FP16x16>, y_values: Tensor<FP16x16>
) -> Tensor<FP16x16> {
let mut rescale_predictions = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
let mut y_min_array = ArrayTrait::<FP16x16>::new();
let mut y_max_array = ArrayTrait::<FP16x16>::new();
let mut y_range_array = ArrayTrait::<FP16x16>::new();
let mut y_max = y_values.max_in_tensor();
let mut y_min = y_values.min_in_tensor();
let mut y_range = y_values.max_in_tensor() - y_values.min_in_tensor();
let y_min_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![y_min].span());
let y_max_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![y_max].span());
let y_range_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![y_range].span());
rescale_predictions = (prediction_result * y_range_tensor) + y_min_tensor;
return rescale_predictions;
} |
mod test;
mod data_preprocessing;
mod helper_functions;
mod datasets;
mod model;
|
mod linear_regression_model;
mod multiple_linear_regression_model;
|
use orion::operators::tensor::{
Tensor, TensorTrait, FP16x16Tensor, U32Tensor, U32TensorAdd, FP16x16TensorSub, FP16x16TensorAdd,
FP16x16TensorDiv, FP16x16TensorMul
};
use orion::numbers::{FP16x16, FixedTrait};
use multiple_linear_regresion::data_preprocessing::{Dataset, DatasetTrait};
use multiple_linear_regresion::helper_functions::{
get_tensor_data_by_row, transpose_tensor, calculate_mean, calculate_r_score,
normalize_user_x_inputs, rescale_predictions
}; |
struct LinearRegressionModel {
gradient: Tensor<FP16x16>,
bias: Tensor<FP16x16>
}
impl RegressionOperation of LinearRegressionModelTrait {
fn predict(ref self: LinearRegressionModel, x_input: Tensor<FP16x16>) -> Tensor<FP16x16> {
let gradient = self.gradient;
let bias = self.bias;
let mut prediction = (gradient * x_input) + bias;
return prediction;
}
}
fn LinearRegression(dataset: Dataset) -> LinearRegressionModel {
let gradient = compute_gradient(dataset);
let bias = compute_bias(dataset);
return LinearRegressionModel { gradient, bias };
}
fn compute_mean(tensor_data: Tensor<FP16x16>) -> Tensor<FP16x16> {
let tensor_size = FixedTrait::<FP16x16>::new_unscaled(tensor_data.data.len(), false);
let cumulated_sum = tensor_data.cumsum(0, Option::None(()), Option::None(()));
let sum_result = cumulated_sum.data[tensor_data.data.len() - 1];
let mean = *sum_result / tensor_size;
let mut result_tensor = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![mean].span());
return result_tensor;
}
fn deviation_from_mean(tensor_data: Tensor<FP16x16>) -> Tensor<FP16x16> {
let mut tensor_data_ = tensor_data;
let mean_value = calculate_mean(tensor_data);
let mut tensor_shape = array::ArrayTrait::new();
tensor_shape.append(tensor_data.data.len());
let mut deviation_values = array::ArrayTrait::new();
let mut i: u32 = 0;
loop {
match tensor_data_.data.pop_front() {
Option::Some(tensor_val) => {
let distance_from_mean = *tensor_val - mean_value;
deviation_values.append(distance_from_mean);
i += 1;
},
Option::None(_) => { break; }
};
};
let distance_from_mean_tensor = TensorTrait::<
FP16x16
>::new(tensor_shape.span(), deviation_values.span());
return distance_from_mean_tensor;
}
fn compute_gradient(dataset: Dataset) -> Tensor<FP16x16> {
let x_deviation = deviati |
on_from_mean(dataset.x_values);
let y_deviation = deviation_from_mean(dataset.y_values);
let x_y_covariance = x_deviation.matmul(@y_deviation);
let x_variance = x_deviation.matmul(@x_deviation);
let beta_value = x_y_covariance / x_variance;
return beta_value;
}
fn compute_bias(dataset: Dataset) -> Tensor<FP16x16> {
let x_mean = compute_mean(dataset.x_values);
let y_mean = compute_mean(dataset.y_values);
let gradient = compute_gradient(dataset);
let mx = gradient * x_mean;
let intercept = y_mean - mx;
return intercept;
} |
use orion::operators::tensor::{
Tensor, TensorTrait, FP16x16Tensor, U32Tensor, U32TensorAdd, FP16x16TensorSub, FP16x16TensorAdd,
FP16x16TensorDiv, FP16x16TensorMul
};
use orion::numbers::{FP16x16, FixedTrait};
use multiple_linear_regresion::data_preprocessing::{Dataset, DatasetTrait};
use multiple_linear_regresion::helper_functions::{
get_tensor_data_by_row, transpose_tensor, calculate_mean, calculate_r_score,
normalize_user_x_inputs, rescale_predictions
}; |
struct MultipleLinearRegressionModel {
coefficients: Tensor<FP16x16>
}
impl RegressionOperation of MultipleLinearRegressionModelTrait {
fn predict(
ref self: MultipleLinearRegressionModel, feature_inputs: Tensor<FP16x16>
) -> Tensor<FP16x16> {
let mut prediction_result = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
let mut result = ArrayTrait::<FP16x16>::new();
if feature_inputs.shape.len() > 1 {
let feature_values = add_bias_term(feature_inputs, 1);
let mut data_len: u32 = *feature_values.shape.at(0);
let mut i: u32 = 0;
loop {
if i >= data_len {
break ();
}
let feature_row_values = get_tensor_data_by_row(feature_values, i);
let predicted_values = feature_row_values.matmul(@self.coefficients);
result.append(*predicted_values.data.at(0));
i += 1;
};
prediction_result =
TensorTrait::<
FP16x16
>::new(shape: array![result.len()].span(), data: result.span());
}
if feature_inputs.shape.len() == 1 && self.coefficients.data.len() > 1 {
let feature_values = add_bias_term(feature_inputs, 1);
prediction_result = feature_values.matmul(@self.coefficients);
}
return prediction_result;
}
}
fn MultipleLinearRegression(dataset: Dataset) -> MultipleLinearRegressionModel {
let x_values_tranposed = transpose_tensor(dataset.x_values);
let x_values_tranposed_with_bias = add_bias_term(x_values_tranposed, 0);
let decorrelated_x_features = decorrelate_x_features(x_values_tranposed_with_bias);
let coefficients = compute_gradients(
decorrelated_x_features, dataset.y_values, x_values_tranposed_with_bias
);
return MultipleLinearRegressionModel { coefficien |
ts };
}
fn add_bias_term(x_feature: Tensor<FP16x16>, axis: u32) -> Tensor<FP16x16> {
let mut x_feature_ = x_feature;
let mut tensor_with_bias = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
let mut result = ArrayTrait::<FP16x16>::new();
if x_feature.shape.len() > 1 {
let mut index: u32 = 0;
if axis == 1 {
index = 0;
} else {
index = 1;
}
let data_len = *x_feature.shape.at(index);
let mut i: u32 = 0;
loop {
if i >= data_len {
break ();
}
result
.append(FixedTrait::new(65536, false));
i += 1;
};
if axis == 0 {
let res_tensor = TensorTrait::new(
shape: array![1, data_len].span(), data: result.span()
);
tensor_with_bias =
TensorTrait::concat(tensors: array![x_feature, res_tensor].span(), axis: axis);
} else {
let res_tensor = TensorTrait::new(
shape: array![data_len, 1].span(), data: result.span()
);
tensor_with_bias =
TensorTrait::concat(tensors: array![x_feature, res_tensor].span(), axis: axis);
}
}
if x_feature.shape.len() == 1 {
let mut j: u32 = 0;
loop {
match x_feature_.data.pop_front() {
Option::Some(x_val) => {
result.append(*x_val);
j += 1;
},
Option::None(_) => { break; }
};
};
result.append(FixedTrait::new(65536, false));
tensor_with_bias =
TensorTrait::<FP16x16>::new(shape: array![result.len()].span(), data: result.span());
}
return tensor_with_bias;
}
fn decorrelate_x_features(x_feature_data: Tensor<FP16x16>) -> Tensor<FP16x16> {
let mut input_tensor = x_feature_data;
let mut i: u32 = 0;
loo |
p {
if i >= *x_feature_data.shape.at(0) {
break ();
}
let mut placeholder = ArrayTrait::<FP16x16>::new();
let mut feature_row_values = get_tensor_data_by_row(input_tensor, i);
let mut feature_squared = feature_row_values.matmul(@feature_row_values);
if *feature_squared.data.at(0) == FixedTrait::new(0, false) {
feature_squared =
TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
}
let mut j: u32 = i + 1;
loop {
if j >= *x_feature_data.shape.at(0) {
break ();
}
let mut remaining_tensor_values = get_tensor_data_by_row(input_tensor, j);
let feature_cross_product = feature_row_values.matmul(@remaining_tensor_values);
let feature_gradients = feature_cross_product / feature_squared;
remaining_tensor_values = remaining_tensor_values
- (feature_row_values
* feature_gradients);
let mut k: u32 = 0;
loop {
if k >= remaining_tensor_values.data.len() {
break ();
}
placeholder.append(*remaining_tensor_values.data.at(k));
k += 1;
};
j += 1;
};
let mut decorrelated_tensor = TensorTrait::new(
shape: array![*x_feature_data.shape.at(0) - 1 - i, *x_feature_data.shape.at(1)].span(),
data: placeholder.span()
);
let mut original_tensor = input_tensor
.slice(
starts: array![0, 0].span(),
ends: array![i + 1, *x_feature_data.shape.at(1)].span(),
axes: Option::None(()),
steps: Option::Some(array![1, 1].span())
);
input_tensor =
TensorTrait::concat(
tensors: array![original_ |
tensor, decorrelated_tensor].span(), axis: 0
);
i += 1;
};
return input_tensor;
}
fn compute_gradients(
decorrelated_x_features: Tensor<FP16x16>,
y_values: Tensor<FP16x16>,
original_x_tensor_values: Tensor<FP16x16>
) -> Tensor<FP16x16> {
let mut gradient_values_flipped = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
let mut result = ArrayTrait::<FP16x16>::new();
let mut tensor_y_vals = y_values;
let mut i: u32 = *decorrelated_x_features.shape.at(0);
loop {
if i <= 0 {
break ();
}
let index_val = i - 1;
let mut decorelated_feature_row_values = get_tensor_data_by_row(
decorrelated_x_features, index_val
);
let mut decorelated_features_squared = decorelated_feature_row_values
.matmul(@decorelated_feature_row_values);
let mut feature_label_cross_product = tensor_y_vals
.matmul(@decorelated_feature_row_values);
if *decorelated_features_squared.data.at(0) == FixedTrait::new(0, false) {
decorelated_features_squared =
TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::new(10, false)].span());
}
let mut single_gradient_value = feature_label_cross_product
/ decorelated_features_squared;
result.append(*single_gradient_value.data.at(0));
let mut original_x_tensor_row_values = get_tensor_data_by_row(
original_x_tensor_values, index_val
);
tensor_y_vals = tensor_y_vals
- (original_x_tensor_row_values
* single_gradient_value);
i -= 1;
};
let final_gradients = TensorTrait::new(
shape: array![*decorrelated_x_features.shape.at(0)].span(), data: result.span()
);
let mut reverse_grad_array = ArrayTrait::<FP16x16>::new();
let m |
ut data_len: u32 = final_gradients.data.len();
loop {
if data_len <= 0 {
break ();
}
let temp_val = data_len - 1;
reverse_grad_array.append(*final_gradients.data.at(temp_val));
data_len -= 1;
};
let gradient_values_flipped = TensorTrait::<
FP16x16
>::new(shape: array![reverse_grad_array.len()].span(), data: reverse_grad_array.span());
return gradient_values_flipped;
} |
use debug::PrintTrait;
use array::{ArrayTrait, SpanTrait};
use multiple_linear_regresion::datasets::aave_data::aave_x_features::aave_x_features;
use multiple_linear_regresion::datasets::aave_data::aave_y_labels::aave_y_labels;
use multiple_linear_regresion::datasets::boston_data::boston_x_features::boston_x_features;
use multiple_linear_regresion::datasets::boston_data::boston_y_labels::boston_y_labels;
use multiple_linear_regresion::datasets::linear_data::feature_data::x_feature_data;
use multiple_linear_regresion::datasets::linear_data::label_data::y_label_data;
use multiple_linear_regresion::datasets::user_inputs_data::user_inputs_boston_data::user_input_boston_housing;
use multiple_linear_regresion::datasets::user_inputs_data::aave_weth_revenue_data_input::{
aave_weth_revenue_data_input
};
use orion::numbers::{FP16x16, FixedTrait};
use multiple_linear_regresion::model::linear_regression_model::{
LinearRegressionModel, compute_mean, LinearRegression, LinearRegressionModelTrait
};
use multiple_linear_regresion::model::multiple_linear_regression_model::{
MultipleLinearRegressionModel, MultipleLinearRegression, MultipleLinearRegressionModelTrait
};
use multiple_linear_regresion::data_preprocessing::{
Dataset, DatasetTrait, normalize_feature_data, normalize_label_data
};
use multiple_linear_regresion::helper_functions::{
get_tensor_data_by_row, transpose_tensor, calculate_mean, calculate_r_score,
normalize_user_x_inputs, rescale_predictions
};
use orion::operators::tensor::{
Tensor, TensorTrait, FP16x16Tensor, U32Tensor, U32TensorAdd, FP16x16TensorSub, FP16x16TensorAdd,
FP16x16TensorDiv, FP16x16TensorMul
}; |
fn multiple_linear_regression_test() {
let mut main_x_vals = aave_x_features();
let mut main_y_vals = aave_y_labels();
let mut dataset = Dataset { x_values: main_x_vals, y_values: main_y_vals };
let mut normalized_dataset = dataset.normalize_dataset();
let mut model = MultipleLinearRegression(normalized_dataset);
let mut model_coefficients = model.coefficients;
let mut reconstructed_ys = model.predict(normalized_dataset.x_values);
let mut r_squared_score = calculate_r_score(normalized_dataset.y_values, reconstructed_ys);
r_squared_score.print();
assert(
normalized_dataset.x_values.max_in_tensor() <= FixedTrait::new(65536, false),
'normalized x not between 0-1'
);
assert(
normalized_dataset.x_values.min_in_tensor() >= FixedTrait::new(0, false),
'normalized x not between 0-1'
);
assert(
normalized_dataset.y_values.max_in_tensor() <= FixedTrait::new(65536, false),
'normalized y not between 0-1'
);
assert(
normalized_dataset.x_values.min_in_tensor() >= FixedTrait::new(0, false),
'normalized y not between 0-1'
);
assert(
normalized_dataset.x_values.data.len() == main_x_vals.data.len()
&& normalized_dataset.y_values.data.len() == main_y_vals.data.len(),
'normalized data shape mismatch'
);
assert(
model.coefficients.data.len() == *main_x_vals.shape.at(1) + 1,
'coefficient data shape mismatch'
);
assert(r_squared_score >= FixedTrait::new(62259, false), 'AAVE model acc. less than 95%');
let last_7_days_aave_data = aave_weth_revenue_data_input();
let last_7_days_aave_data_normalized = normalize_user_x_inputs(
last_7_days_aave_data, main_x_vals
);
let mut forecast_results = model.predict(last_7_days_aave_data_normalized);
let mut rescale_forecasts = rescale_predictions(
forecast_results, main_y_vals
);
(*rescale_forecasts.data.at(0)).print();
(*rescal |
e_forecasts.data.at(1)).print();
(*rescale_forecasts.data.at(2)).print();
(*rescale_forecasts.data.at(5)).print();
(*rescale_forecasts.data.at(6)).print();
} |
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"
" |
import numpy as np \n",
" |
import pandas as pd \n",
" |
import pprint,random\n",
"\n",
"from scipy.ndimage.interpolation |
import shift\n",
" |
import matplotlib.pyplot as plt\n",
"\n",
"from keras.models |
import Sequential\n",
"from keras.layers |
import Dense,Dropout\n",
"from keras.optimizers |
import SGD"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"In order for a program to learn how to play Tic-Tac-Toe, we first need to create the Tic-Tac-Toe game\n",
"\n",
"Below, we create a simple tic tac toe game using Numpy\n",
"\n",
"Below are the details of the Numpy Tic Tac Toe Game:\n",
"\n",
"* The game board is a 3 * 3 numpy array\n",
"* The below is the denotation used:\n",
" * 2: placeholder/empty cell\n",
" * 0: 'O'\n",
" * 1: 'X'\n",
"* By default, the array is filled with the number 2 as placeholder\n",
"* The number 0 denotes an 'O' and the number 1 denotes an 'X'\n",
"* Players take turns in choosing the coordinates of the numpy array where they will place 0 or 1 respectively\n",
"* The player who succeeds in placing three of their marks in a horizontal, vertical, or diagonal row wins the game\n",
"* For simplicity, the program always plays with the mark 1 and the opponent plays with 0"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
" |
class tic_tac_toe_game(object):\n",
" def __init__(self):\n",
" self.board=np.full((3,3),2)\n",
"\n",
" def toss(self):\n",
" \"\"\"Function to simulate a toss and decide which player goes first\n",
"\n",
" Args:\n",
"\n",
" Returns:\n",
" Returns 1 if player assigned mark 1 has won, or 0 if his opponent won\n",
"\n",
" \"\"\"\n",
" turn=np.random.randint(0,2,size=1)\n",
" if turn.mean()==0:\n",
" self.turn_monitor=0\n",
" elif turn.mean()==1:\n",
" self.turn_monitor=1\n",
" return self.turn_monitor\n",
"\n",
" def move(self,player,coord):\n",
" \"\"\"Function to perform the action of placing a mark on the tic tac toe board\n",
" After performing the action, this function flips the value of the turn_monitor to \n",
" the next player\n",
"\n",
" Args:\n",
" player: 1 if player who is assigned the mark 1 is performing the action, \n",
" 0 if his opponent is performing the action\n",
" coord: The coordinate where the 1 or 0 is to be placed on the \n",
" tic-tac-toe board (numpy array)\n",
"\n",
" Returns:\n",
" game_status(): Calls the game status function and returns its value\n",
" board: Returns the new board state after making the move\n",
"\n",
" \"\"\"\n",
" if self.board[coord]!=2 or self.game_status()!=\"In Progress\" or self.turn_monitor!=player:\n",
" raise ValueError(\"Invalid move\")\n",
" self.board[coord]=player\n",
" self.turn_monitor=1-player\n",
" return self.game_status(),self.board\n",
"\n",
"\n",
" def game_status(self):\n",
" \"\"\"Function to check the current status of the game, \n",
" whether the game has been won, drawn or is in progress\n",
"\n",
" Args:\n", |
"\n",
" Returns:\n",
" \"Won\" if the game has been won, \"Drawn\" if the \n",
" game has been drawn, or \"In Progress\", if the game is still in progress\n",
"\n",
" \"\"\"\n",
"
" for i in range(self.board.shape[0]):\n",
" if 2 not in self.board[i,:] and len(set(self.board[i,:]))==1:\n",
" return \"Won\"\n",
"
" for j in range(self.board.shape[1]):\n",
" if 2 not in self.board[:,j] and len(set(self.board[:,j]))==1:\n",
" return \"Won\"\n",
"
" if 2 not in np.diag(self.board) and len(set(np.diag(self.board)))==1:\n",
" return \"Won\"\n",
" if 2 not in np.diag(np.fliplr(self.board)) and len(set(np.diag(np.fliplr(self.board))))==1:\n",
" return \"Won\"\n",
"
" if not 2 in self.board:\n",
" return \"Drawn\"\n",
" else:\n",
" return \"In Progress\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"\n",
"To simply test the tic-tac-toe game created above, let us play a dummy game. We make the moves for both the players."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"
"game=tic_tac_toe_game()\n",
"
"game.toss()\n",
"print(\"Player \",game.turn_monitor,\" has won the toss\")\n",
"
"print(\"Initial board state \\n\",game.board)\n",
"print(\"Let first player place their mark on 0,0\")\n",
"game_status,board=game.move(game.turn_monitor,(0,0))\n",
"print(\"New Board State: \\n\",board)\n",
"print(\"Let second player place their mark on 0,1\")\n",
"game_status,board=game.move(game.turn_monitor,(0,1))\n",
"print(\"New Board State: \\n\",board)\n",
"print(\"Let first player place their mark on 1,1\")\n",
"game_status,board=game.move(game.turn_monitor,(1,1))\n",
"prin |
t(\"New Board State: \\n\",board)\n",
"print(\"Let second player place their mark on 0,2\")\n",
"game_status,board=game.move(game.turn_monitor,(0,2))\n",
"print(\"New Board State: \\n\",board)\n",
"print(\"Let first player place their mark on 2,2\")\n",
"game_status,board=game.move(game.turn_monitor,(2,2))\n",
"print(\"New Board State: \\n\",board)\n",
"print(\"Player \",1-game.turn_monitor,\" Has \",game_status)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"\n",
"The legal moves genator accepts the board state and player as input, and provides the set of all possible legal moves as output.\n",
"\n",
"Basically, for a given board state and player, it tells us where all the player can place his mark legally (the player can only place the mark where there is no opponent's mark)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def legal_moves_generator(current_board_state,turn_monitor):\n",
" \"\"\"Function that returns the set of all possible legal moves and resulting board states, \n",
" for a given input board state and player\n",
"\n",
" Args:\n",
" current_board_state: The current board state\n",
" turn_monitor: 1 if it's the player who places the mark 1's turn to play, 0 if its his opponent's turn\n",
"\n",
" Returns:\n",
" legal_moves_dict: A dictionary of a list of possible next coordinate-resulting board state pairs\n",
" The resulting board state is flattened to 1 d array\n",
"\n",
" \"\"\"\n",
" legal_moves_dict={}\n",
" for i in range(current_board_state.shape[0]):\n",
" for j in range(current_board_state.shape[1]):\n",
" if current_board_state[i,j]==2:\n",
" board_state_copy=current_board_state.copy()\n",
" board_state_copy[i,j]=turn_monitor\n",
" legal_moves_dict[(i,j)]=board_sta |
te_copy.flatten()\n",
" return legal_moves_dict"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"\n",
"Let us test the above created Legal Moves Generator.\n",
"\n",
"We start a dummy game, and do the toss. We then pass the current board state and toss winner to the Legal Moves Generator. It returns the dictionary of legal moves that it returns the dictionary is of the form \"possible next legal move coordinate\":\"flattened resulting board state\""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"game=tic_tac_toe_game()\n",
"game.toss()\n",
"print(\"Player \",game.turn_monitor,\" has won the toss\")\n",
"print(\"Current board state \\n\",game.board)\n",
"legal_moves_dict=legal_moves_generator(game.board,game.turn_monitor)\n",
"print(\"Dictionary of Possible Next Legal Moves:\")\n",
"pprint.pprint(legal_moves_dict)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can observe above that the Legal Moves Generator returns a dictionary with all the possible legal coordinates and their resulting flattened numpy board states"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As defined previously, the Evaluator function maps board states to scores.\n",
"\n",
"It is expected that after training, the Evaluator learns to assign higher scores to board states that are favourable to the program.\n",
"In our kernel, we use a neural network as an Evaluator Function.\n",
"\n",
"Below, we create the neural network. The weights of the neural network are intialized randomly.\n",
"The neural network takes the flattened tic-tac-toe board numpy array as input and outputs a score."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"model = |
Sequential()\n",
"model.add(Dense(18, input_dim=9,kernel_initializer='normal', activation='relu'))\n",
"model.add(Dropout(0.1))\n",
"model.add(Dense(9, kernel_initializer='normal',activation='relu'))\n",
"model.add(Dropout(0.1))\n",
"model.add(Dense(1,kernel_initializer='normal'))\n",
"\n",
"learning_rate = 0.001\n",
"momentum = 0.8\n",
"\n",
"sgd = SGD(lr=learning_rate, momentum=momentum,nesterov=False)\n",
"model.compile(loss='mean_squared_error', optimizer=sgd)\n",
"model.summary()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"\n",
"The Program Move Selector selects the next move for a player given the current board state using the following approach:\n",
"* Use the Legal Moves Generator to get all the possible next legal board states.\n",
"* Use the Evaluator (model) to score each possible next board state.\n",
"* The next board state that is assigned the highest score is selected as the next board state.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def move_selector(model,current_board_state,turn_monitor):\n",
" \"\"\"Function that selects the next move to make from a set of possible legal moves\n",
"\n",
" Args:\n",
" model: The Evaluator function to use to evaluate each possible next board state\n",
" turn_monitor: 1 if it's the player who places the mark 1's turn to play, 0 if its his opponent's turn\n",
"\n",
" Returns:\n",
" selected_move: The numpy array coordinates where the player should place thier mark\n",
" new_board_state: The flattened new board state resulting from performing above selected move\n",
" score: The score that was assigned to the above selected_move by the Evaluator (model)\n",
"\n",
" \"\"\"\n",
" tracker={}\n",
" legal_moves_dict=legal_moves_generator(current_board_state,turn_monitor)\n",
" for legal_m |
ove_coord in legal_moves_dict:\n",
" score=model.predict(legal_moves_dict[legal_move_coord].reshape(1,9))\n",
" tracker[legal_move_coord]=score\n",
" selected_move=max(tracker, key=tracker.get)\n",
" new_board_state=legal_moves_dict[selected_move]\n",
" score=tracker[selected_move]\n",
" return selected_move,new_board_state,score"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"\n",
"Let us play a dummy game and use the above created Program Move Selector function to select the next move"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"
"game=tic_tac_toe_game()\n",
"
"game.toss()\n",
"
"print(\"Player assigned mark 1\",game.turn_monitor,\" won the toss\")\n",
"print(\"Initial board state:\")\n",
"print(game.board)\n",
"selected_move,new_board_state,score=move_selector(model,game.board,game.turn_monitor)\n",
"print(\"Selected move: \",selected_move)\n",
"print(\"Resulting new board state: \",new_board_state)\n",
"print(\"Score assigned to above board state by Evaluator(model): \", score)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Please note that since the Evaluator (model) has not yet been trained and has been assigned random weights, hence the score above is a random number"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For our program to self learn, it needs to play several games of tic-tac-toe.\n",
"\n",
"But with who will it play with?\n",
"\n",
"The program learns by playing games against a coded opponent.\n",
"\n",
"The opponent is coded to do the following:\n",
"\n",
"1. If playing in \"Easy\" mode:\n",
"\n",
" * When it is your turn, use the Legal Moves Generator to get all possible legal next moves\n" |
,
" * Pick a legal move at random\n",
" * Repeat above until the end of the game\n",
"\n",
"2. If playing in \"Hard\" mode:\n",
"\n",
" * When it is your turn, use the Legal Moves Generator to get all possible legal next moves\n",
" * Of the above legal moves, if any legal move makes you win (along row/column/diagonal), pick that legal move\n",
" * Else, if any legal move prevents your opponent (program) from winning when it is one move away from a win, pick that move\n",
" * Else, if any legal move leads to a row/diagonal/column having two 0's and no 1's (program's mark) , pick that legal move\n",
" * If none of the above conditions exist, pick a legal move at random\n",
"\n",
"The Program is trained by repeatedly playing games against the above opponent and updating the weights of the model at the end of each game.\n",
"\n",
"Each game is played at either \"Easy\" or \"Hard\" mode, which is picked at random at the start of each game.\n",
"\n",
"The \"Easy\" mode helps the Program explore the tic-tac-toe space. The \"Hard\" mode helps the Program learn how to play with a real opponent."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def row_winning_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan rowwise and identify coordinate amongst the legal coordinates that will\n",
" result in a winning board state\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to win for the opponent\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" curren |
t_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
"
" for i in range(current_board_state_copy.shape[0]):\n",
" if 2 not in current_board_state_copy[i,:] and len(set(current_board_state_copy[i,:]))==1:\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def column_winning_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan column wise and identify coordinate amongst the legal coordinates that will\n",
" result in a winning board state\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
"\n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to win for the opponent\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" for j in range(current_board_state_copy.shape[1]):\n",
" if 2 not in current_board_state_copy[:,j] and len(set(current_board_state_copy[:,j]))==1:\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
"\n",
"def diag1_winning_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan diagonal and identify coordinate amongst the legal coordinates that will\n",
" result in a winning board state\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
"\n",
" Returns:\n",
" |
selected_move: The coordinates of numpy array where placing the 0 will lead to win for the opponent\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" if 2 not in np.diag(current_board_state_copy) and len(set(np.diag(current_board_state_copy)))==1:\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def diag2_winning_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan second diagonal and identify coordinate amongst the legal coordinates that will\n",
" result in a winning board state\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
"\n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to win for the opponent\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" if 2 not in np.diag(np.fliplr(current_board_state_copy)) and len(set(np.diag(np.fliplr(current_board_state_copy))))==1:\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"
"\n",
"def row_block_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan rowwise and identify coordinate amongst the legal coordinates \n",
" that will prevent the program |
\n",
" from winning\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will block 1 from winning\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" for i in range(current_board_state_copy.shape[0]):\n",
" if 2 not in current_board_state_copy[i,:] and (current_board_state_copy[i,:]==1).sum()==2:\n",
" if not (2 not in current_board_state[i,:] and (current_board_state[i,:]==1).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def column_block_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan column wise and identify coordinate amongst the legal coordinates that will prevent 1 \n",
" from winning\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will block 1 from winning\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" \n",
" for j in range(current_board_state_copy.shape[1]):\n",
" |
if 2 not in current_board_state_copy[:,j] and (current_board_state_copy[:,j]==1).sum()==2:\n",
" if not (2 not in current_board_state[:,j] and (current_board_state[:,j]==1).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
"\n",
"def diag1_block_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan diagonal 1 and identify coordinate amongst the legal coordinates that will prevent 1 \n",
" from winning\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will block 1 from winning\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor \n",
" if 2 not in np.diag(current_board_state_copy) and (np.diag(current_board_state_copy)==1).sum()==2:\n",
" if not (2 not in np.diag(current_board_state) and (np.diag(current_board_state)==1).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def diag2_block_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan second diagonal wise and identify coordinate amongst the legal coordinates that will\n",
" result in a column having only 0s\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: Th |
e coordinates of numpy array where placing the 0 will lead to two 0s being there (and no 1s)\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" if 2 not in np.diag(np.fliplr(current_board_state_copy)) and (np.diag(np.fliplr(current_board_state_copy))==1).sum()==2:\n",
" if not (2 not in np.diag(np.fliplr(current_board_state)) and (np.diag(np.fliplr(current_board_state))==1).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
"\n",
"
"def row_second_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan rowwise and identify coordinate amongst the legal coordinates that will\n",
" result in a row having two 0s and no 1s\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to two 0s being there (and no 1s)\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" \n",
" for i in range(current_board_state_copy.shape[0]):\n",
" if 1 not in current_board_state_copy[i,:] and (current_board_state_copy[i,:]==0).sum()==2:\n",
" if not (1 not in current_board_state[i,:] and (current_board_state[i,:]==0).sum()==2):\n",
" |
selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def column_second_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan column wise and identify coordinate amongst the legal coordinates that will\n",
" result in a column having two 0s and no 1s\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to two 0s being there (and no 1s)\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" \n",
" for j in range(current_board_state_copy.shape[1]):\n",
" if 1 not in current_board_state_copy[:,j] and (current_board_state_copy[:,j]==0).sum()==2:\n",
" if not (1 not in current_board_state[:,j] and (current_board_state[:,j]==0).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
"\n",
"def diag1_second_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan diagonal wise and identify coordinate amongst the legal coordinates that will\n",
" result in a column having two 0s and no 1s\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to two 0s being there (and no 1s)\n",
"\n", |
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" if 1 not in np.diag(current_board_state_copy) and (np.diag(current_board_state_copy)==0).sum()==2:\n",
" if not (1 not in np.diag(current_board_state) and (np.diag(current_board_state)==0).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def diag2_second_move_check(current_board_state,legal_moves_dict,turn_monitor):\n",
" \"\"\"Function to scan second diagonal wise and identify coordinate amongst \n",
" the legal coordinates that will result in a column having two 0s and no 1s\n",
"\n",
" Args:\n",
" legal_moves_dict: Dictionary of legal next moves\n",
" turn_monitor: whose turn it is to move\n",
" \n",
" Returns:\n",
" selected_move: The coordinates of numpy array where opponent places their mark\n",
"\n",
" \"\"\" \n",
" legal_move_coords = list(legal_moves_dict.keys())\n",
" random.shuffle(legal_move_coords)\n",
" for legal_move_coord in legal_move_coords:\n",
" current_board_state_copy=current_board_state.copy()\n",
" current_board_state_copy[legal_move_coord]=turn_monitor\n",
" if 1 not in np.diag(np.fliplr(current_board_state_copy)) and (np.diag(np.fliplr(current_board_state_copy))==0).sum()==2:\n",
" if not (1 not in np.diag(np.fliplr(current_board_state)) and (np.diag(np.fliplr(current_board_state))==0).sum()==2):\n",
" selected_move=legal_move_coord\n",
" return selected_move\n",
" \n",
"def opponent_move_selector(current_board_state,turn_monitor,mode):\n",
" \"\"\"F |
unction that picks a legal move for the opponent\n",
"\n",
" Args:\n",
" current_board_state: Current board state\n",
" turn_monitor: whose turn it is to move\n",
" mode: whether hard or easy mode\n",
"\n",
" Returns:\n",
" selected_move: The coordinates of numpy array where placing the 0 will lead to two 0s being there (and no 1s)\n",
"\n",
" \"\"\" \n",
" legal_moves_dict=legal_moves_generator(current_board_state,turn_monitor)\n",
" \n",
" winning_move_checks=[row_winning_move_check,column_winning_move_check,diag1_winning_move_check,diag2_winning_move_check]\n",
" block_move_checks=[row_block_move_check,column_block_move_check,diag1_block_move_check,diag2_block_move_check]\n",
" second_move_checks=[row_second_move_check,column_second_move_check,diag1_second_move_check,diag2_second_move_check]\n",
"\n",
" if mode==\"Hard\":\n",
" random.shuffle(winning_move_checks)\n",
" random.shuffle(block_move_checks)\n",
" random.shuffle(second_move_checks) \n",
" \n",
" for fn in winning_move_checks:\n",
" if fn(current_board_state,legal_moves_dict,turn_monitor):\n",
" return fn(current_board_state,legal_moves_dict,turn_monitor)\n",
" \n",
" for fn in block_move_checks:\n",
" if fn(current_board_state,legal_moves_dict,turn_monitor):\n",
" return fn(current_board_state,legal_moves_dict,turn_monitor)\n",
" \n",
" for fn in second_move_checks:\n",
" if fn(current_board_state,legal_moves_dict,turn_monitor):\n",
" return fn(current_board_state,legal_moves_dict,turn_monitor)\n",
" \n",
" selected_move=random.choice(list(legal_moves_dict.keys()))\n",
" return selected_move\n",
" \n",
" elif mode==\"Easy\":\n",
" legal_moves_dict=legal_moves_generator(cu |
rrent_board_state,turn_monitor)\n",
" selected_move=random.choice(list(legal_moves_dict.keys()))\n",
" return selected_move"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"\n",
"Training the progam is essentially training the Evaluator(model) to assign higher scores to board states favourable to the program, and lower scores to board states unfavourable to the program.\n",
"\n",
"The progam is expected to learn by playing games against the Opponent.\n",
"\n",
"The Evaluator (model) is trained in the following way:\n",
"\n",
"* At first the weights of the model are randomly assigned\n",
"* Using this model, the Move Selector function selects the next move to make for the program\n",
"* The program and the opponent make thier moves until the game ends\n",
"* After the game is completed, the scores are corrected as follows:\n",
" * If the game was Won by the program, assign the score 1 to the final board state, or assign -1 if lost or 0 if drawn\n",
" * Shift the remaining scores so that they become the scores of the previous board states\n",
" * Update the weights of the model using the board state and corrected score\n",
"* The above process is repeated over 100s of thousands of games\n",
"* It is expected that eventually, the Evaluator (model) learns to assign higher scores to more favourable board states and lower scores to less favourable board states"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def train(model,mode,print_progress=False):\n",
" \"\"\"Function trains the Evaluator (model) by playing a game against an opponent \n",
" playing random moves, and updates the weights of the model after the game\n",
" \n",
" Note that the model weights are updated using SGD with a batch size of 1\n",
"\n",
" Args:\n",
" model: The Evaluator function being trained\n", |
"\n",
" Returns:\n",
" model: The model updated using SGD\n",
" y: The corrected scores\n",
"\n",
" \"\"\" \n",
"
" if print_progress==True:\n",
" print(\"___________________________________________________________________\")\n",
" print(\"Starting a new game\")\n",
" game=tic_tac_toe_game()\n",
" game.toss()\n",
" scores_list=[]\n",
" corrected_scores_list=[]\n",
" new_board_states_list=[]\n",
" \n",
" while(1):\n",
" if game.game_status()==\"In Progress\" and game.turn_monitor==1:\n",
"
" selected_move,new_board_state,score=move_selector(model,game.board,game.turn_monitor)\n",
" scores_list.append(score[0][0])\n",
" new_board_states_list.append(new_board_state)\n",
"
" game_status,board=game.move(game.turn_monitor,selected_move)\n",
" if print_progress==True:\n",
" print(\"Program's Move\")\n",
" print(board)\n",
" print(\"\\n\")\n",
" elif game.game_status()==\"In Progress\" and game.turn_monitor==0:\n",
" selected_move=opponent_move_selector(game.board,game.turn_monitor,mode=mode)\n",
" \n",
"
" game_status,board=game.move(game.turn_monitor,selected_move)\n",
" if print_progress==True:\n",
" print(\"Opponent's Move\")\n",
" print(board)\n",
" print(\"\\n\")\n",
" else:\n",
" break\n",
"\n",
" \n",
"
"
" new_board_states_list=tuple(new_board_states_list)\n",
" new_board_states_list=np.vstack(new_board_states_list)\n",
" if game_status==\"Won\" and (1-game.turn_monitor)==1: \n",
" corrected_scores_list=shift(scores_list,-1,cval=1.0)\n",
" result=\"Won\"\n",
" if game_status==\"Won\ |
" and (1-game.turn_monitor)!=1:\n",
" corrected_scores_list=shift(scores_list,-1,cval=-1.0)\n",
" result=\"Lost\"\n",
" if game_status==\"Drawn\":\n",
" corrected_scores_list=shift(scores_list,-1,cval=0.0)\n",
" result=\"Drawn\"\n",
" if print_progress==True:\n",
" print(\"Program has \",result)\n",
" print(\"\\n Correcting the Scores and Updating the model weights:\")\n",
" print(\"___________________________________________________________________\\n\")\n",
" \n",
" x=new_board_states_list\n",
" y=corrected_scores_list\n",
" \n",
" def unison_shuffled_copies(a, b):\n",
" assert len(a) == len(b)\n",
" p = np.random.permutation(len(a))\n",
" return a[p], b[p]\n",
" \n",
"
" x,y=unison_shuffled_copies(x,y)\n",
" x=x.reshape(-1,9) \n",
" \n",
"
" model.fit(x,y,epochs=1,batch_size=1,verbose=0)\n",
" return model,y,result"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"\n",
"Note that the program will always play the mark '1' and the opponent will always play mark '0'.\n",
"\n",
"below, we run a single iteration of training, or in other words, a single game of tic-tac-toe between the program and opponent."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"updated_model,y,result=train(model,mode=\"Hard\",print_progress=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"\n",
"We play 200,000 games of tic-tac-toe between the program and the opponent. We record the result of each game and plot the distribution of wins/losses/draws by the program over fixed intervals of games"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"game_counter=1\n",
"data_for_graph= |
pd.DataFrame()\n",
"\n",
"mode_list=[\"Easy\",\"Hard\"]\n",
"\n",
"while(game_counter<=200000):\n",
" mode_selected=np.random.choice(mode_list, 1, p=[0.5,0.5])\n",
" model,y,result=train(model,mode=mode_selected[0],print_progress=False)\n",
"
" if game_counter % 10000 == 0:\n",
" print(\"Game
" print(\"Mode: \",mode_selected[0])\n",
" game_counter+=1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"model.save('model/ttt.h5')
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"Below you can play against AI agent"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def play_with_model(model):\n",
"
" game = tic_tac_toe_game()\n",
" game.toss()\n",
" current_player = \"Human\" if game.turn_monitor == 0 else \"Model\"\n",
"\n",
" print(f\"{current_player} won the toss\")\n",
"\n",
"
" while game.game_status() == \"In Progress\":\n",
" print(\"Current board state:\")\n",
" print(game.board)\n",
" \n",
" if game.turn_monitor == 0:
" valid_move = False\n",
" while not valid_move:\n",
" try:\n",
" move_row = int(input(\"Enter the row where you want to place your mark (0, 1, 2): \"))\n",
" move_col = int(input(\"Enter the column where you want to place your mark (0, 1, 2): \"))\n",
" game_status, board = game.move(0, (move_row, move_col))\n",
" valid_move = True\n",
" except ValueError as e:\n",
" print(e)\n",
" print(\"Try again.\")\n",
" else:
" selected_move, new_board_state, score = move_selector(model, game.board, game.turn_monitor) |
\n",
" game_status, board = game.move(1, selected_move)\n",
" print(f\"Model places at {selected_move}\")\n",
"\n",
" print(f\"Game Over! Status: {game_status}\")\n",
" print(\"Final board state:\")\n",
" print(game.board)\n",
"\n",
"model = load_model('ttt.h5')\n",
"play_with_model(model)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"! pip install onnx\n",
"! pip install keras2onnx\n",
"! pip install tensorflow\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from tensorflow.python.keras.models |
import load_model\n",
" |
import os\n",
"os.environ['TF_KERAS'] = '1'\n",
" |
import onnxmltools\n",
"\n",
"\n",
"model = load_model('model/ttt.h5')\n",
"onnx_model = onnxmltools.convert_keras(model) \n",
"\n",
"onnxmltools.utils.save_model(onnx_model, 'model/ttt.onnx')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
" |
import onnx\n",
"\n",
"
"onnx_model = onnx.load('model/ttt.onnx')\n",
"onnx.checker.check_model(onnx_model)\n",
"\n",
"
"print(onnx_model.graph)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.9"
}
},
"nbformat": 4,
"nbformat_minor": 2
} |
use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![18,].span(),
data: array![
FP16x16 { mag: 77099, sign: true },
FP16x16 { mag: 140625, sign: true },
FP16x16 { mag: 59258, sign: true },
FP16x16 { mag: 40408, sign: false },
FP16x16 { mag: 66634, sign: true },
FP16x16 { mag: 27092, sign: false },
FP16x16 { mag: 3196, sign: true },
FP16x16 { mag: 392, sign: true },
FP16x16 { mag: 81839, sign: true },
FP16x16 { mag: 39890, sign: true },
FP16x16 { mag: 16196, sign: false },
FP16x16 { mag: 59646, sign: false },
FP16x16 { mag: 55690, sign: false },
FP16x16 { mag: 181170, sign: true },
FP16x16 { mag: 22719, sign: true },
FP16x16 { mag: 91746, sign: false },
FP16x16 { mag: 141435, sign: true },
FP16x16 { mag: 123843, sign: true },
]
.span()
}
}
|
use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![9, 18,].span(),
data: array![
FP16x16 { mag: 3955, sign: false },
FP16x16 { mag: 31098, sign: true },
FP16x16 { mag: 56097, sign: false },
FP16x16 { mag: 5925, sign: true },
FP16x16 { mag: 11807, sign: false },
FP16x16 { mag: 14772, sign: true },
FP16x16 { mag: 62093, sign: true },
FP16x16 { mag: 2509, sign: true },
FP16x16 { mag: 78328, sign: false },
FP16x16 { mag: 112161, sign: true },
FP16x16 { mag: 39446, sign: true },
FP16x16 { mag: 75575, sign: true },
FP16x16 { mag: 2793, sign: true },
FP16x16 { mag: 86022, sign: false },
FP16x16 { mag: 2420, sign: true },
FP16x16 { mag: 64022, sign: true },
FP16x16 { mag: 13386, sign: false },
FP16x16 { mag: 36355, sign: true },
FP16x16 { mag: 60754, sign: false },
FP16x16 { mag: 6195, sign: true },
FP16x16 { mag: 32924, sign: false },
FP16x16 { mag: 18469, sign: false },
FP16x16 { mag: 77241, sign: true },
FP16x16 { mag: 41273, sign: false },
FP16x16 { mag: 1430, sign: true },
FP16x16 { mag: 892, sign: true },
FP16x16 { mag: 32289, sign: false },
FP16x16 { mag: 21674, sign: false },
FP16x16 { mag: 88897, sign: true },
FP16x16 { mag: 74800, sign: true },
FP16x16 { mag: 56068, sign: true },
FP16x16 { mag: 16620, sign: false },
FP16x16 { mag: 21513, sign: true },
FP16x16 { mag: 19496, sign: false },
FP16x16 { mag: 61824, sign: false },
FP16x16 { mag: 26766, sign: true },
FP16x16 { mag: 16 |
100, sign: true },
FP16x16 { mag: 33159, sign: false },
FP16x16 { mag: 45269, sign: true },
FP16x16 { mag: 41714, sign: true },
FP16x16 { mag: 4038, sign: true },
FP16x16 { mag: 12259, sign: true },
FP16x16 { mag: 23497, sign: true },
FP16x16 { mag: 2852, sign: true },
FP16x16 { mag: 16666, sign: false },
FP16x16 { mag: 90011, sign: true },
FP16x16 { mag: 89479, sign: true },
FP16x16 { mag: 47499, sign: true },
FP16x16 { mag: 2231, sign: false },
FP16x16 { mag: 42105, sign: true },
FP16x16 { mag: 27305, sign: true },
FP16x16 { mag: 54180, sign: true },
FP16x16 { mag: 24296, sign: true },
FP16x16 { mag: 53924, sign: false },
FP16x16 { mag: 7000, sign: false },
FP16x16 { mag: 4234, sign: true },
FP16x16 { mag: 41393, sign: false },
FP16x16 { mag: 24115, sign: false },
FP16x16 { mag: 18438, sign: false },
FP16x16 { mag: 13772, sign: false },
FP16x16 { mag: 30782, sign: false },
FP16x16 { mag: 1532, sign: false },
FP16x16 { mag: 14289, sign: false },
FP16x16 { mag: 19607, sign: false },
FP16x16 { mag: 44319, sign: false },
FP16x16 { mag: 20825, sign: true },
FP16x16 { mag: 206, sign: false },
FP16x16 { mag: 85743, sign: false },
FP16x16 { mag: 5984, sign: false },
FP16x16 { mag: 28843, sign: true },
FP16x16 { mag: 33272, sign: true },
FP16x16 { mag: 4101, sign: true },
FP16x16 { mag: 10691, sign: true },
FP16x16 { mag: 66566, sign: false },
FP16x16 { mag: 1461, sign: true },
FP16x16 { mag: 64292, sign: true },
FP16x16 { mag: 9889, sign: false },
FP16x16 { mag: 1602, sign: true },
FP16x16 { mag: 79586, sign: false }, |
FP16x16 { mag: 860, sign: true },
FP16x16 { mag: 16922, sign: true },
FP16x16 { mag: 13655, sign: false },
FP16x16 { mag: 3763, sign: false },
FP16x16 { mag: 13831, sign: false },
FP16x16 { mag: 16606, sign: true },
FP16x16 { mag: 31081, sign: true },
FP16x16 { mag: 1148, sign: true },
FP16x16 { mag: 7401, sign: true },
FP16x16 { mag: 5918, sign: false },
FP16x16 { mag: 172902, sign: true },
FP16x16 { mag: 16803, sign: true },
FP16x16 { mag: 2761, sign: false },
FP16x16 { mag: 60016, sign: true },
FP16x16 { mag: 57641, sign: true },
FP16x16 { mag: 25229, sign: true },
FP16x16 { mag: 409, sign: true },
FP16x16 { mag: 4561, sign: false },
FP16x16 { mag: 2739, sign: true },
FP16x16 { mag: 33103, sign: false },
FP16x16 { mag: 15444, sign: true },
FP16x16 { mag: 2938, sign: true },
FP16x16 { mag: 9677, sign: false },
FP16x16 { mag: 1959, sign: false },
FP16x16 { mag: 48004, sign: true },
FP16x16 { mag: 21527, sign: true },
FP16x16 { mag: 13099, sign: true },
FP16x16 { mag: 4516, sign: true },
FP16x16 { mag: 61344, sign: false },
FP16x16 { mag: 24844, sign: true },
FP16x16 { mag: 20932, sign: false },
FP16x16 { mag: 32461, sign: false },
FP16x16 { mag: 21037, sign: false },
FP16x16 { mag: 3844, sign: true },
FP16x16 { mag: 63076, sign: true },
FP16x16 { mag: 116403, sign: true },
FP16x16 { mag: 47, sign: true },
FP16x16 { mag: 167757, sign: true },
FP16x16 { mag: 33293, sign: false },
FP16x16 { mag: 8474, sign: false },
FP16x16 { mag: 36467, sign: true },
FP16x16 { mag: 5361, sign: false },
FP16x16 { mag: 94574, sign: |
false },
FP16x16 { mag: 3961, sign: true },
FP16x16 { mag: 20948, sign: false },
FP16x16 { mag: 8617, sign: false },
FP16x16 { mag: 9743, sign: true },
FP16x16 { mag: 67822, sign: false },
FP16x16 { mag: 7211, sign: true },
FP16x16 { mag: 32215, sign: true },
FP16x16 { mag: 18519, sign: false },
FP16x16 { mag: 58230, sign: false },
FP16x16 { mag: 41745, sign: true },
FP16x16 { mag: 8810, sign: true },
FP16x16 { mag: 4189, sign: true },
FP16x16 { mag: 7625, sign: false },
FP16x16 { mag: 17757, sign: false },
FP16x16 { mag: 6851, sign: false },
FP16x16 { mag: 15698, sign: false },
FP16x16 { mag: 68976, sign: true },
FP16x16 { mag: 8665, sign: false },
FP16x16 { mag: 144, sign: false },
FP16x16 { mag: 72523, sign: true },
FP16x16 { mag: 70719, sign: false },
FP16x16 { mag: 21577, sign: true },
FP16x16 { mag: 28121, sign: true },
FP16x16 { mag: 20052, sign: false },
FP16x16 { mag: 46946, sign: true },
FP16x16 { mag: 87657, sign: true },
FP16x16 { mag: 33678, sign: true },
FP16x16 { mag: 48832, sign: true },
FP16x16 { mag: 4698, sign: true },
FP16x16 { mag: 878, sign: true },
FP16x16 { mag: 41781, sign: true },
FP16x16 { mag: 12867, sign: true },
FP16x16 { mag: 1281, sign: true },
FP16x16 { mag: 12234, sign: false },
FP16x16 { mag: 5716, sign: true },
FP16x16 { mag: 48745, sign: true },
FP16x16 { mag: 11140, sign: false },
FP16x16 { mag: 22035, sign: true },
FP16x16 { mag: 9363, sign: true },
FP16x16 { mag: 67049, sign: false },
]
.span()
}
} |
use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![9,].span(),
data: array![
FP16x16 {mag: 1241, sign: true}, FP16x16 {mag: 32808, sign: true}, FP16x16 {mag: 5666, sign: false}, FP16x16 {mag: 896, sign: false}, FP16x16 {mag: 12018, sign: false}, FP16x16 {mag: 11826, sign: false}, FP16x16 {mag: 3795, sign: false}, FP16x16 {mag: 13949, sign: false}, FP16x16 {mag: 3218, sign: true}, ].span()
}
}
|
use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![18,9,].span(),
data: array![
FP16x16 {mag: 2465, sign: false}, FP16x16 {mag: 2340, sign: false}, FP16x16 {mag: 32664, sign: true}, FP16x16 {mag: 16005, sign: false}, FP16x16 {mag: 40259, sign: true}, FP16x16 {mag: 37822, sign: true}, FP16x16 {mag: 2872, sign: true}, FP16x16 {mag: 39356, sign: true}, FP16x16 {mag: 1725, sign: true}, FP16x16 {mag: 11180, sign: true}, FP16x16 {mag: 34264, sign: false}, FP16x16 {mag: 6638, sign: false}, FP16x16 {mag: 3478, sign: false}, FP16x16 {mag: 14102, sign: true}, FP16x16 {mag: 12535, sign: true}, FP16x16 {mag: 12001, sign: true}, FP16x16 {mag: 18569, sign: true}, FP16x16 {mag: 22851, sign: true}, FP16x16 {mag: 12523, sign: false}, FP16x16 {mag: 26931, sign: false}, FP16x16 {mag: 3529, sign: true}, FP16x16 {mag: 13909, sign: true}, FP16x16 {mag: 23747, sign: false}, FP16x16 {mag: 29669, sign: false}, FP16x16 {mag: 14539, sign: false}, FP16x16 {mag: 27740, sign: false}, FP16x16 {mag: 18385, sign: false}, FP16x16 {mag: 30201, sign: true}, FP16x16 {mag: 13759, sign: true}, FP16x16 {mag: 11985, sign: true}, FP16x16 {mag: 71619, sign: false}, FP16x16 {mag: 19944, sign: false}, FP16x16 {mag: 4239, sign: false}, FP16x16 {mag: 33485, sign: true}, FP16x16 {mag: 6481, sign: true}, FP16x16 {mag: 33629, sign: true}, FP16x16 {mag: 2260, sign: false}, FP16x16 {mag: 6532, sign: true}, FP16x16 {mag: 5292, sign: true}, FP16x16 {mag: 24375, sign: false}, FP16x16 {mag: 13574, sign: false}, FP16x16 {mag: 8645, sign: false}, FP16x16 {mag: 7671, sign: false}, FP16x16 {mag: 14861, sign: false}, FP16x16 {mag: 12084, sign: false}, FP16x16 {mag: 7675, sign: true}, FP16x16 {mag: 4015, sign: true}, FP16x16 {mag: 22250, sign: true}, FP16x16 {mag: 15436, sign: true}, FP16x16 {mag: 28003, sign: false}, FP16x16 {mag: 18767, sign: false}, FP16x16 {mag: 6382, sign |
: true}, FP16x16 {mag: 31147, sign: false}, FP16x16 {mag: 5390, sign: false}, FP16x16 {mag: 17990, sign: false}, FP16x16 {mag: 39474, sign: false}, FP16x16 {mag: 9985, sign: false}, FP16x16 {mag: 33327, sign: true}, FP16x16 {mag: 29900, sign: true}, FP16x16 {mag: 23978, sign: true}, FP16x16 {mag: 9985, sign: false}, FP16x16 {mag: 12197, sign: true}, FP16x16 {mag: 7435, sign: true}, FP16x16 {mag: 639, sign: false}, FP16x16 {mag: 2532, sign: true}, FP16x16 {mag: 5910, sign: false}, FP16x16 {mag: 2848, sign: false}, FP16x16 {mag: 4306, sign: false}, FP16x16 {mag: 1856, sign: true}, FP16x16 {mag: 1251, sign: true}, FP16x16 {mag: 1589, sign: true}, FP16x16 {mag: 2191, sign: true}, FP16x16 {mag: 1067, sign: false}, FP16x16 {mag: 37203, sign: true}, FP16x16 {mag: 4686, sign: false}, FP16x16 {mag: 40127, sign: true}, FP16x16 {mag: 33823, sign: true}, FP16x16 {mag: 23325, sign: true}, FP16x16 {mag: 35514, sign: false}, FP16x16 {mag: 2639, sign: true}, FP16x16 {mag: 46695, sign: false}, FP16x16 {mag: 49480, sign: false}, FP16x16 {mag: 24483, sign: true}, FP16x16 {mag: 2421, sign: true}, FP16x16 {mag: 22600, sign: true}, FP16x16 {mag: 10720, sign: false}, FP16x16 {mag: 5655, sign: false}, FP16x16 {mag: 36440, sign: false}, FP16x16 {mag: 7469, sign: false}, FP16x16 {mag: 37046, sign: false}, FP16x16 {mag: 32540, sign: true}, FP16x16 {mag: 23355, sign: true}, FP16x16 {mag: 18911, sign: true}, FP16x16 {mag: 19967, sign: false}, FP16x16 {mag: 7995, sign: false}, FP16x16 {mag: 2876, sign: false}, FP16x16 {mag: 28494, sign: true}, FP16x16 {mag: 3640, sign: false}, FP16x16 {mag: 55301, sign: true}, FP16x16 {mag: 19263, sign: true}, FP16x16 {mag: 28503, sign: true}, FP16x16 {mag: 20567, sign: true}, FP16x16 {mag: 19075, sign: false}, FP16x16 {mag: 12334, sign: false}, FP16x16 {mag: 9320, sign: false}, FP16x16 {mag: 302, sign: true}, FP16x16 {mag: 8293, sign: false}, FP16x16 {mag: 48929, sign: true}, FP16x16 {mag: 9371, sign: true}, FP16x16 {mag: 7195, sign: false}, FP16x16 {mag: 9507, sign: true}, FP16x16 {mag: 27072, sign: true}, |
FP16x16 {mag: 31023, sign: false}, FP16x16 {mag: 28161, sign: false}, FP16x16 {mag: 15273, sign: true}, FP16x16 {mag: 27178, sign: false}, FP16x16 {mag: 7702, sign: true}, FP16x16 {mag: 11518, sign: false}, FP16x16 {mag: 10741, sign: false}, FP16x16 {mag: 20454, sign: false}, FP16x16 {mag: 26801, sign: true}, FP16x16 {mag: 27046, sign: true}, FP16x16 {mag: 24313, sign: true}, FP16x16 {mag: 14909, sign: false}, FP16x16 {mag: 28354, sign: true}, FP16x16 {mag: 17081, sign: false}, FP16x16 {mag: 7418, sign: false}, FP16x16 {mag: 25151, sign: false}, FP16x16 {mag: 8309, sign: false}, FP16x16 {mag: 4019, sign: false}, FP16x16 {mag: 16244, sign: true}, FP16x16 {mag: 981, sign: true}, FP16x16 {mag: 306, sign: true}, FP16x16 {mag: 3737, sign: false}, FP16x16 {mag: 6126, sign: false}, FP16x16 {mag: 12213, sign: true}, FP16x16 {mag: 38450, sign: true}, FP16x16 {mag: 22926, sign: true}, FP16x16 {mag: 5183, sign: true}, FP16x16 {mag: 32450, sign: true}, FP16x16 {mag: 30705, sign: true}, FP16x16 {mag: 43870, sign: true}, FP16x16 {mag: 26190, sign: true}, FP16x16 {mag: 54292, sign: true}, FP16x16 {mag: 3506, sign: true}, FP16x16 {mag: 12819, sign: false}, FP16x16 {mag: 46049, sign: true}, FP16x16 {mag: 241, sign: true}, FP16x16 {mag: 64050, sign: true}, FP16x16 {mag: 50948, sign: true}, FP16x16 {mag: 1238, sign: true}, FP16x16 {mag: 52562, sign: true}, FP16x16 {mag: 2508, sign: false}, FP16x16 {mag: 46211, sign: false}, FP16x16 {mag: 7648, sign: true}, FP16x16 {mag: 43005, sign: false}, FP16x16 {mag: 24333, sign: true}, FP16x16 {mag: 20222, sign: true}, FP16x16 {mag: 18892, sign: true}, FP16x16 {mag: 34596, sign: false}, FP16x16 {mag: 16295, sign: true}, FP16x16 {mag: 5455, sign: true}, ].span()
}
} |
use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![1,].span(),
data: array![
FP16x16 {mag: 17046, sign: false}, ].span()
}
}
|
use array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16Tensor;
use orion::numbers::{FixedTrait, FP16x16};
fn tensor() -> Tensor<FP16x16> {
Tensor {
shape: array![9,1,].span(),
data: array![
FP16x16 {mag: 15010, sign: true}, FP16x16 {mag: 27195, sign: true}, FP16x16 {mag: 36261, sign: true}, FP16x16 {mag: 26590, sign: false}, FP16x16 {mag: 23070, sign: false}, FP16x16 {mag: 29654, sign: false}, FP16x16 {mag: 25429, sign: true}, FP16x16 {mag: 28541, sign: false}, FP16x16 {mag: 27150, sign: true}, ].span()
}
}
|
#[starknet::contract]
mod OrionRunner {
use core::array::SpanTrait;
use orion::operators::tensor::{TensorTrait, FP16x16Tensor, Tensor, FP16x16TensorAdd};
use orion::operators::nn::{NNTrait, FP16x16NN};
use orion::numbers::{FP16x16, FixedTrait};
use sequential_1_dense_1_matmul_readvariableop_0::tensor as t1;
use sequential_1_dense_1_biasadd_readvariableop_0::tensor as t2;
use sequential_1_dense_2_matmul_readvariableop_0::tensor as t3;
use sequential_1_dense_2_biasadd_readvariableop_0::tensor as t4;
use sequential_1_dense_3_matmul_readvariableop_0::tensor as t5;
use sequential_1_dense_3_biasadd_readvariableop_0::tensor as t6;
#[storage]
struct Storage {
id: u8,
}
#[external(v0)]
fn predict(self: @ContractState, mut x: Tensor<FP16x16>) -> FP16x16 {
// let two = FixedTrait::<FP16x16>::new_unscaled(2, false);
// let mut x = Tensor {
// shape: array![9].span(),
// data: array![two, two, two, two, two, two, two, two, two].span()
// };
// DENSE 1
x = TensorTrait::matmul(@x, @t1());
x = x + t2();
x = NNTrait::relu(@x);
// DENSE 2
x = TensorTrait::matmul(@x, @t3());
x = x + t4();
x = NNTrait::relu(@x);
// DENSE 3
x = TensorTrait::matmul(@x, @t5());
x = x + t6();
return *x.data.at(0);
}
}
|
mod inference;
mod test; |
#[cfg(test)]
mod tests {
use core::array::SpanTrait;
use orion::operators::tensor::{TensorTrait, FP16x16Tensor, Tensor, FP16x16TensorAdd};
use orion::operators::nn::{NNTrait, FP16x16NN};
use orion::numbers::{FP16x16, FixedTrait};
use sequential_1_dense_1_matmul_readvariableop_0::tensor as _sequential_1_dense_1_matmul_readvariableop_0;
use sequential_1_dense_1_biasadd_readvariableop_0::tensor as _sequential_1_dense_1_biasadd_readvariableop_0;
use sequential_1_dense_2_matmul_readvariableop_0::tensor as _sequential_1_dense_2_matmul_readvariableop_0;
use sequential_1_dense_2_biasadd_readvariableop_0::tensor as _sequential_1_dense_2_biasadd_readvariableop_0;
use sequential_1_dense_3_matmul_readvariableop_0::tensor as _sequential_1_dense_3_matmul_readvariableop_0;
use sequential_1_dense_3_biasadd_readvariableop_0::tensor as _sequential_1_dense_3_biasadd_readvariableop_0;
use debug::PrintTrait;
#[test]
#[available_gas(2000000000000)]
fn _main() {
let two = FixedTrait::<FP16x16>::new_unscaled(2, false);
let mut x = Tensor {
shape: array![9].span(),
data: array![two, two, two, two, two, two, two, two, two].span()
};
// DENSE 1
x = TensorTrait::matmul(@x, @_sequential_1_dense_1_matmul_readvariableop_0());
x = x + _sequential_1_dense_1_biasadd_readvariableop_0();
x = NNTrait::relu(@x);
// DENSE 2
x = TensorTrait::matmul(@x, @_sequential_1_dense_2_matmul_readvariableop_0());
x = x + _sequential_1_dense_2_biasadd_readvariableop_0();
x = NNTrait::relu(@x);
// DENSE 3
x = TensorTrait::matmul(@x, @_sequential_1_dense_3_matmul_readvariableop_0());
x = x + _sequential_1_dense_3_biasadd_readvariableop_0();
(*x.data.at(0)).print();
}
}
|
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_keys;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::srs::gen_srs;
use ezkl::pfsys::TranscriptType;
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
static mut KERNEL_HEIGHT: usize = 2;
static mut KERNEL_WIDTH: usize = 2;
static mut OUT_CHANNELS: usize = 1;
static mut IMAGE_HEIGHT: usize = 2;
static mut IMAGE_WIDTH: usize = 2;
static mut IN_CHANNELS: usize = 1;
const K: usize = 17; |
struct MyCircuit {
image: ValTensor<Fr>,
kernel: ValTensor<Fr>,
bias: ValTensor<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = 10;
let a = VarTensor::new_advice(cs, K, 1, len * len);
let b = VarTensor::new_advice(cs, K, 1, len * len);
let output = VarTensor::new_advice(cs, K, 1, (len + 1) * len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(
&mut region,
&[self.image.clone(), self.kernel.clone(), self.bias.clone()],
Box::new(PolyOp::Conv {
padding: vec![(0, 0)],
stride: vec![1; 2],
}),
)
.unwrap();
Ok(())
},
)?;
Ok(())
}
} |
fn runcnvrl(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_conv");
let params = gen_srs::<KZGCommitmentScheme<_>>(K as u32);
for size in [1, 2, 4].iter() {
unsafe {
KERNEL_HEIGHT = size * 2;
KERNEL_WIDTH = size * 2;
IMAGE_HEIGHT = size * 4;
IMAGE_WIDTH = size * 4;
IN_CHANNELS = 1;
OUT_CHANNELS = 1;
let mut image = Tensor::from(
(0..IN_CHANNELS * IMAGE_HEIGHT * IMAGE_WIDTH)
.map(|_| Value::known(Fr::random(OsRng))),
);
image
.reshape(&[1, IN_CHANNELS, IMAGE_HEIGHT, IMAGE_WIDTH])
.unwrap();
let mut kernel = Tensor::from(
(0..{ OUT_CHANNELS * IN_CHANNELS * KERNEL_HEIGHT * KERNEL_WIDTH })
.map(|_| Fr::random(OsRng)),
);
kernel
.reshape(&[OUT_CHANNELS, IN_CHANNELS, KERNEL_HEIGHT, KERNEL_WIDTH])
.unwrap();
kernel.set_visibility(&ezkl::graph::Visibility::Private);
let mut bias = Tensor::from((0..{ OUT_CHANNELS }).map(|_| Fr::random(OsRng)));
bias.set_visibility(&ezkl::graph::Visibility::Private);
let circuit = MyCircuit {
image: ValTensor::from(image),
kernel: ValTensor::try_from(kernel).unwrap(),
bias: ValTensor::try_from(bias).unwrap(),
};
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk = create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_ |
input(BenchmarkId::new("prove", size), &size, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runcnvrl
}
criterion_main!(benches); |
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
static mut LEN: usize = 4;
const K: usize = 16; |
struct MyCircuit {
inputs: [ValTensor<Fr>; 2],
_marker: PhantomData<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len);
let b = VarTensor::new_advice(cs, K, 1, len);
let output = VarTensor::new_advice(cs, K, 1, len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(
&mut region,
&self.inputs,
Box::new(PolyOp::Einsum {
equation: "i,i->".to_string(),
}),
)
.unwrap();
Ok(())
},
)?;
Ok(())
}
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.