text
stringlengths 1
2.05k
|
|---|
import json"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"with open(\"conv2D_input.json\", \"w\") as f:\n",
" json.dump(in_json, f)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"inputs = Input(shape=(10,10,3))\n",
"x = Conv2D(2, 4, 3)(inputs)\n",
"model = Model(inputs, x)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: \"model_1\"\n",
"_________________________________________________________________\n",
" Layer (type) Output Shape Param
"=================================================================\n",
" input_2 (InputLayer) [(None, 10, 10, 3)] 0 \n",
" \n",
" conv2d_1 (Conv2D) (None, 3, 3, 2) 98 \n",
" \n",
"=================================================================\n",
"Total params: 98\n",
"Trainable params: 98\n",
"Non-trainable params: 0\n",
"_________________________________________________________________\n"
]
}
],
"source": [
"model.summary()"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<tf.Variable 'conv2d_1/kernel:0' shape=(4, 4, 3, 2) dtype=float32, numpy=\n",
" array([[[[-0.2644725 , -0.06314689],\n",
" [-0.19228128, -0.15511811],\n",
" [ 0.11695373, 0.15373573]],\n",
" \n",
" [[-0.25127184, -0.03327389],\n",
" [ 0.06582499, 0.13954943],\n",
" [-0.02274385, -0.24024239]],\n",
" \n",
" |
[[-0.27345484, 0.07233012],\n",
" [ 0.03240535, -0.1362924 ],\n",
" [ 0.16554734, -0.19980597]],\n",
" \n",
" [[ 0.12271923, -0.16348948],\n",
" [-0.24399345, 0.11112538],\n",
" [ 0.04153693, 0.09944585]]],\n",
" \n",
" \n",
" [[[ 0.07061589, 0.08067289],\n",
" [-0.25938636, -0.04698843],\n",
" [-0.18615322, -0.18926641]],\n",
" \n",
" [[ 0.06828818, 0.10024589],\n",
" [-0.06301631, -0.21391404],\n",
" [ 0.17798159, 0.16077739]],\n",
" \n",
" [[-0.18883933, -0.24141382],\n",
" [-0.1410877 , -0.1870578 ],\n",
" [-0.17638391, 0.12909776]],\n",
" \n",
" [[ 0.24995095, -0.27214956],\n",
" [-0.16633804, -0.24534652],\n",
" [ 0.09470761, -0.1752578 ]]],\n",
" \n",
" \n",
" [[[-0.26973695, -0.16573134],\n",
" [ 0.0093652 , 0.23317659],\n",
" [ 0.13521832, -0.18823144]],\n",
" \n",
" [[ 0.1731261 , 0.15210795],\n",
" [ 0.11972865, 0.11824197],\n",
" [-0.20316267, -0.01294529]],\n",
" \n",
" [[ 0.14585042, 0.22254854],\n",
" [ 0.15764701, 0.0891107 ],\n",
" [ 0.00702351, 0.17262942]],\n",
" \n",
" [[ 0.06677854, -0.07873373],\n",
" [-0.26536292, -0.1721809 ],\n",
" [-0.12418044, -0.11808449]]],\n",
" \n",
" \n",
" [[[ 0.09153298, 0.18611383],\n",
" [ 0.14009333, -0.19381046],\n",
" [-0.27251363, 0.07429421]],\n",
" \n",
" [[ 0.12720028, -0.08216412],\n",
" [ 0.14116141, -0.10473494],\n",
" [-0.01652202, -0.11998361]],\n",
" \n",
" [[-0.010129 , |
0.12356687],\n",
" [-0.00215057, 0.17525265],\n",
" [ 0.26925737, 0.18551975]],\n",
" \n",
" [[-0.1616565 , -0.14463529],\n",
" [-0.18055108, 0.2564476 ],\n",
" [ 0.19239256, -0.11366163]]]], dtype=float32)>,\n",
" <tf.Variable 'conv2d_1/bias:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)>]"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.weights"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[[[0.74916437, 0.48058547, 0.76332072],\n",
" [0.12424725, 0.17444765, 0.23397784],\n",
" [0.05504572, 0.73761126, 0.8872156 ],\n",
" [0.49900099, 0.92746041, 0.53705474],\n",
" [0.55972545, 0.16210532, 0.48132197],\n",
" [0.5848511 , 0.49854495, 0.08101739],\n",
" [0.18151106, 0.19916602, 0.72216404],\n",
" [0.8740212 , 0.76936566, 0.77574156],\n",
" [0.640459 , 0.97982307, 0.28733369],\n",
" [0.72894846, 0.08559827, 0.88796122]],\n",
"\n",
" [[0.72655621, 0.74204472, 0.22625834],\n",
" [0.04455912, 0.02637621, 0.7410693 ],\n",
" [0.59282978, 0.27570664, 0.76839831],\n",
" [0.98853958, 0.32472733, 0.07214331],\n",
" [0.18975449, 0.50827871, 0.61454778],\n",
" [0.04411632, 0.5425321 , 0.08095671],\n",
" [0.98276969, 0.93905031, 0.27580299],\n",
" [0.01991902, 0.18288148, 0.56430848],\n",
" [0.60873785, 0.76133969, 0.94420434],\n",
" [0.29177495, 0.60971797, 0.75330394]],\n",
"\n",
" [[0.73958658, 0.86792802, 0.38199042],\n",
" [0.60758291, 0.04444527, 0.89773701],\n",
" [0.813 |
78908, 0.74925507, 0.94127002],\n",
" [0.52276966, 0.71515635, 0.0673889 ],\n",
" [0.88674225, 0.85171248, 0.25796752],\n",
" [0.06304501, 0.02557175, 0.7862988 ],\n",
" [0.13024858, 0.03026337, 0.53165512],\n",
" [0.98698478, 0.10343698, 0.14793739],\n",
" [0.19595613, 0.4755287 , 0.69081615],\n",
" [0.63616236, 0.64746281, 0.70686306]],\n",
"\n",
" [[0.90697061, 0.70755438, 0.17101648],\n",
" [0.91618436, 0.75457803, 0.3753285 ],\n",
" [0.10891312, 0.63256771, 0.66998965],\n",
" [0.0031363 , 0.8577421 , 0.44313256],\n",
" [0.97431053, 0.31491313, 0.52870403],\n",
" [0.84949509, 0.57476833, 0.35833646],\n",
" [0.3259322 , 0.61810256, 0.97382616],\n",
" [0.92587238, 0.93189425, 0.02385008],\n",
" [0.91665173, 0.21392593, 0.48478448],\n",
" [0.43780191, 0.31732276, 0.10383084]],\n",
"\n",
" [[0.40302491, 0.18641359, 0.28439078],\n",
" [0.80467361, 0.95795027, 0.76525912],\n",
" [0.09050706, 0.05142721, 0.5484936 ],\n",
" [0.72498561, 0.5350264 , 0.47320043],\n",
" [0.83032011, 0.36968621, 0.17519239],\n",
" [0.80183789, 0.53486298, 0.63113123],\n",
" [0.98299635, 0.17220543, 0.99893277],\n",
" [0.98120285, 0.15965491, 0.11500732],\n",
" [0.50294074, 0.54067477, 0.58704542],\n",
" [0.30811939, 0.86034992, 0.96053741]],\n",
"\n",
" [[0.51231231, 0.36679594, 0.6387736 ],\n",
" [0.39364612, 0.65398604, 0.18194537],\n",
" [0.53904627, 0.31794439, 0.95598346],\n",
" [0.8201467 , 0.01759052, 0.21272062],\n",
" [0.8265654 , 0.62113986, 0.56095777],\n",
" [0.24749834, 0.71107743, 0.22825303],\n",
" [0.174 |
45456, 0.27443303, 0.53532667],\n",
" [0.46250432, 0.81471236, 0.01852107],\n",
" [0.86219207, 0.21628477, 0.98052948],\n",
" [0.34121289, 0.33599059, 0.95218908]],\n",
"\n",
" [[0.37520805, 0.46358272, 0.96812602],\n",
" [0.08123441, 0.61637145, 0.90839157],\n",
" [0.40060218, 0.47543454, 0.64913812],\n",
" [0.90053796, 0.70871333, 0.55043711],\n",
" [0.39746646, 0.30778257, 0.88554719],\n",
" [0.86349263, 0.11219438, 0.85574671],\n",
" [0.62224992, 0.48989345, 0.63991367],\n",
" [0.99134928, 0.98989598, 0.6173012 ],\n",
" [0.04768804, 0.33779174, 0.18604113],\n",
" [0.01957013, 0.57973428, 0.7495305 ]],\n",
"\n",
" [[0.10672299, 0.71601061, 0.03377451],\n",
" [0.87905429, 0.78474207, 0.59381131],\n",
" [0.90857691, 0.96590608, 0.56500479],\n",
" [0.13149743, 0.52407683, 0.23988054],\n",
" [0.56993435, 0.26299209, 0.7549793 ],\n",
" [0.52225825, 0.6448658 , 0.04444777],\n",
" [0.03641049, 0.37206738, 0.94614889],\n",
" [0.51144329, 0.88620609, 0.59531982],\n",
" [0.45414305, 0.41827663, 0.08097343],\n",
" [0.40615607, 0.26751879, 0.03898047]],\n",
"\n",
" [[0.89224853, 0.12348574, 0.32034526],\n",
" [0.64800157, 0.82504082, 0.19296447],\n",
" [0.88471839, 0.64119493, 0.03698128],\n",
" [0.99176407, 0.59193617, 0.30150652],\n",
" [0.72020934, 0.56545044, 0.91065986],\n",
" [0.80514643, 0.29937785, 0.74242392],\n",
" [0.09456567, 0.46145516, 0.554788 ],\n",
" [0.46704768, 0.33370513, 0.56795916],\n",
" [0.55089935, 0.89252818, 0.01030941],\n",
" [0.68112324, 0.5390893 , 0.31510111]],\n",
"\n",
" |
[[0.94967068, 0.7825868 , 0.22214195],\n",
" [0.8453802 , 0.98304469, 0.98455021],\n",
" [0.50376912, 0.29307285, 0.78424416],\n",
" [0.26351673, 0.24259793, 0.48663014],\n",
" [0.42359605, 0.48513857, 0.55338817],\n",
" [0.22229073, 0.02676846, 0.15701487],\n",
" [0.35682851, 0.72597313, 0.64578716],\n",
" [0.60649997, 0.55222217, 0.01019997],\n",
" [0.28450479, 0.20816085, 0.19723797],\n",
" [0.95701904, 0.54230762, 0.38779384]]]])"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = np.random.rand(1,10,10,3)\n",
"X"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1/1 [==============================] - 0s 22ms/step\n"
]
},
{
"data": {
"text/plain": [
"array([[[[-0.02103192, -0.00251862],\n",
" [-0.13590473, -0.43280643],\n",
" [-0.46592993, -0.6076722 ]],\n",
"\n",
" [[-0.41985548, -0.28316095],\n",
" [-0.5124401 , -0.67603445],\n",
" [-0.30362517, -0.35066307]],\n",
"\n",
" [[ 0.04719239, -0.77217025],\n",
" [-0.90729254, -0.5460546 ],\n",
" [-0.6157329 , -0.56018454]]]], dtype=float32)"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y = model.predict(X)\n",
"y"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"X_in = [[[int(X[0][i][j][k]*1e36) for k in range(3)] for j in range(10)] for i in range(10)]\n",
"weights = [[[[int(model.weights[0].numpy()[i][j][k][l]*1e36) for l in range(2)] for k in range(3)] for j in range(4)] for i i |
n range(4)]\n",
"bias = [int(model.weights[1].numpy()[i]*1e72) for i in range(2)]"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"([[['21888242871839275222246405745257275088548343368429240512769054624061005959510',\n",
" '21888242871839275222246405745257275088548361881856976212445268734113123308000'],\n",
" ['21888242871839275222246405745257275088548228495669861064087547662558271715284',\n",
" '21888242871839275222246405745257275088547931594040764149614699120473995978124'],\n",
" ['21888242871839275222246405745257275088547898470480336398546468994244949638791',\n",
" '21888242871839275222246405745257275088547756728190784802798484857861334105370']],\n",
" [['21888242871839275222246405745257275088547944544909737422432087456874316949324',\n",
" '21888242871839275222246405745257275088548081239515185091772880603232052577114'],\n",
" ['21888242871839275222246405745257275088547851960358367500079371782793385911358',\n",
" '21888242871839275222246405745257275088547688365801627855012444638213091512422'],\n",
" ['21888242871839275222246405745257275088548060775297780413313747663983226225838',\n",
" '21888242871839275222246405745257275088548013737249302248990923589248334943730']],\n",
" [['47192436853842599651386952076755831',\n",
" '21888242871839275222246405745257275088547592230115531216981433877552691800835'],\n",
" ['21888242871839275222246405745257275088547457107943733886642827877231280519319',\n",
" '21888242871839275222246405745257275088547818345751775722192552561821918626804'],\n",
" ['21888242871839275222246405745257275088547748667480051924165721939129997507240',\n",
" '21888242871839275222246405745257275088547804215881906491939765109262983554318']]],\n",
" [[['268679458635749205024295605371928576',\n",
" '388806143166359782280358980933910 |
528'],\n",
" ['587604291442575449740007779803856896',\n",
" '881363922854357799836717369522126848'],\n",
" ['861312932060957897553390674280185856',\n",
" '857846252928472736899563405831045120']],\n",
" [['84829649070177990320832563715768320',\n",
" '765867543468158475751770347286822912'],\n",
" ['238136771858729786452041694885969920',\n",
" '231361799849937010319349760697303040'],\n",
" ['357728239843398972090727278133116928',\n",
" '121546057864506428255684370605539328']],\n",
" [['568749905268752884676825625665732608',\n",
" '218395840383827537600516408079286272'],\n",
" ['390713141622087796116893701035261952',\n",
" '52043981850152859332227036686057472'],\n",
" ['355515461237650726718816599152787456',\n",
" '178351211698736250757067221797699584']]])"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_in, weights, bias, out, remainder = Conv2DInt(10, 10, 3, 2, 4, 3, 10**36, X_in, weights, bias)\n",
"out, remainder"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"in_json = {\n",
" \"in\": X_in,\n",
" \"weights\": weights,\n",
" \"bias\": bias,\n",
" \"out\": out,\n",
" \"remainder\": remainder\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"with open(\"conv2D_stride_input.json\", \"w\") as f:\n",
" json.dump(in_json, f)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "sklearn",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mim |
etype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.16"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
} |
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from tensorflow.keras.layers |
import Input, Conv2D\n",
"from tensorflow.keras |
import Model\n",
" |
import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"inputs = Input(shape=(5,5,3))\n",
"x = Conv2D(2, 3, padding=\"same\")(inputs)\n",
"model = Model(inputs, x)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: \"model\"\n",
"_________________________________________________________________\n",
" Layer (type) Output Shape Param
"=================================================================\n",
" input_1 (InputLayer) [(None, 5, 5, 3)] 0 \n",
" \n",
" conv2d (Conv2D) (None, 5, 5, 2) 56 \n",
" \n",
"=================================================================\n",
"Total params: 56\n",
"Trainable params: 56\n",
"Non-trainable params: 0\n",
"_________________________________________________________________\n"
]
}
],
"source": [
"model.summary()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<tf.Variable 'conv2d/kernel:0' shape=(3, 3, 3, 2) dtype=float32, numpy=\n",
" array([[[[-0.22388998, 0.18217945],\n",
" [-0.31254017, 0.13933456],\n",
" [-0.14491144, 0.01168695]],\n",
" \n",
" [[-0.18442051, 0.16668755],\n",
" [-0.15052032, -0.1277689 ],\n",
" [-0.17660408, -0.25577286]],\n",
" \n",
" [[-0.3273484 , 0.06551823],\n",
" [ 0.02335805, 0.30579627],\n",
" [ 0.05012453, 0.05196694]]],\n",
" \n",
" \n",
" [[[- |
0.15296353, -0.28653675],\n",
" [ 0.31760007, 0.27596015],\n",
" [ 0.06140944, 0.28459537]],\n",
" \n",
" [[-0.271937 , 0.3022167 ],\n",
" [ 0.34724104, 0.3508402 ],\n",
" [-0.26121286, -0.10477605]],\n",
" \n",
" [[ 0.18311954, 0.15618789],\n",
" [ 0.21608043, 0.07763481],\n",
" [-0.17695144, -0.29946056]]],\n",
" \n",
" \n",
" [[[ 0.2186423 , 0.2389586 ],\n",
" [-0.2976641 , -0.30056122],\n",
" [-0.35727727, -0.3631401 ]],\n",
" \n",
" [[-0.04230955, -0.15279846],\n",
" [ 0.06897295, -0.08147189],\n",
" [-0.30367035, 0.21289521]],\n",
" \n",
" [[-0.2920769 , -0.22767249],\n",
" [-0.29041147, -0.2403323 ],\n",
" [-0.20408599, -0.23004377]]]], dtype=float32)>,\n",
" <tf.Variable 'conv2d/bias:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)>]"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.weights"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[[[0.57357832, 0.79689708, 0.54481385],\n",
" [0.95096481, 0.06302099, 0.53424686],\n",
" [0.14555327, 0.16801407, 0.91837743],\n",
" [0.14042694, 0.26466775, 0.0754911 ],\n",
" [0.19354151, 0.89796698, 0.18080666]],\n",
"\n",
" [[0.84893864, 0.94689375, 0.76889793],\n",
" [0.91280106, 0.81211903, 0.50614878],\n",
" [0.72629997, 0.09620774, 0.05074255],\n",
" [0.30178926, 0.4854865 , 0.46486629],\n",
" [0.87558861, 0.93289185, 0.33965317]],\n",
"\n",
" [[0.23726595, 0.09253935, 0.085 |
98877],\n",
" [0.24484708, 0.00811252, 0.23642884],\n",
" [0.65975124, 0.63633904, 0.82507772],\n",
" [0.53100731, 0.72433054, 0.66373751],\n",
" [0.43916625, 0.74347257, 0.6772263 ]],\n",
"\n",
" [[0.87412193, 0.53853422, 0.34772628],\n",
" [0.7738511 , 0.97565729, 0.94426861],\n",
" [0.21537231, 0.65774623, 0.89405016],\n",
" [0.7411118 , 0.68792609, 0.3272619 ],\n",
" [0.44887834, 0.924486 , 0.48269841]],\n",
"\n",
" [[0.13952337, 0.79659803, 0.97603335],\n",
" [0.66099459, 0.06934143, 0.99854059],\n",
" [0.31609368, 0.49596104, 0.93797069],\n",
" [0.04941322, 0.24709554, 0.58384416],\n",
" [0.71527804, 0.48976864, 0.98763569]]]])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = np.random.rand(1,5,5,3)\n",
"X"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1/1 [==============================] - 0s 51ms/step\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2024-02-04 01:25:53.532541: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
]
},
{
"data": {
"text/plain": [
"array([[[[-0.7382064 , -0.17332056],\n",
" [-1.034698 , -0.43408912],\n",
" [-0.83073455, -0.6865788 ],\n",
" [-0.28542495, 0.0770359 ],\n",
" [-0.04129319, 0.02877748]],\n",
"\n",
" [[-0.60671365, 0.38846642],\n",
" [-1.1027374 , 0.71167284],\n",
" [-1.2792461 , -0.10405768],\n",
" [-1.1375024 , -0.28573734],\n",
" [-0.7037988 , 0.3554073 ]] |
,\n",
"\n",
" [[-1.5469512 , -0.50975496],\n",
" [-2.0071907 , -0.25512454],\n",
" [-1.9879558 , 0.09278526],\n",
" [-1.5013543 , -0.14000578],\n",
" [-0.7585893 , 0.43752092]],\n",
"\n",
" [[-0.7614179 , 0.09177176],\n",
" [-1.688165 , -0.25309083],\n",
" [-0.8684121 , 0.42702955],\n",
" [-1.6322078 , 0.3133433 ],\n",
" [-1.1236074 , 0.2770568 ]],\n",
"\n",
" [[-0.54382604, 0.415062 ],\n",
" [-1.0068984 , 0.6469521 ],\n",
" [-1.3391564 , 0.42430705],\n",
" [-0.6338484 , 0.63813394],\n",
" [-0.9111921 , 0.5726407 ]]]], dtype=float32)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y = model.predict(X)\n",
"y"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"X_in = [[[int(X[0][i][j][k]*1e36) for k in range(3)] for j in range(5)] for i in range(5)]\n",
"weights = [[[[int(model.weights[0].numpy()[i][j][k][l]*1e36) for l in range(2)] for k in range(3)] for j in range(3)] for i in range(3)]\n",
"bias = [int(model.weights[1].numpy()[i]*1e72) for i in range(2)]"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def Conv2DInt(nRows, nCols, nChannels, nFilters, kernelSize, strides, n, input, weights, bias):\n",
" out = [[[0 for _ in range(nFilters)] for _ in range((nCols - kernelSize)
" remainder = [[[None for _ in range(nFilters)] for _ in range((nCols - kernelSize)
" for i in range((nRows - kernelSize)
" for j in range((nCols - kernelSize)
" for m in range(nFilters):\n",
" for k in range(nChannels):\n",
" for x in range(kernelSize):\n",
" |
for y in range(kernelSize):\n",
" out[i][j][m] += int(input[i*strides+x][j*strides+y][k])*int(weights[x][y][k][m])\n",
" out[i][j][m] += int(bias[m])\n",
" remainder[i][j][m] = str(out[i][j][m] % n)\n",
" out[i][j][m] = str(out[i][j][m]
" return out, remainder"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"def Conv2DsameInt(nRows, nCols, nChannels, nFilters, kernelSize, strides, n, input, weights, bias):\n",
" if nRows % strides == 0:\n",
" rowPadding = max(kernelSize - strides, 0)\n",
" else:\n",
" rowPadding = max(kernelSize - nRows % strides, 0)\n",
" if nCols % strides == 0:\n",
" colPadding = max(kernelSize - strides, 0)\n",
" else:\n",
" colPadding = max(kernelSize - nCols % strides, 0)\n",
" \n",
" _input = [[[0 for _ in range(nChannels)] for _ in range(nCols + colPadding)] for _ in range(nRows + rowPadding)]\n",
"\n",
" for i in range(nRows):\n",
" for j in range(nCols):\n",
" for k in range(nChannels):\n",
" _input[i+rowPadding
" \n",
" out, remainder = Conv2DInt(nRows + rowPadding, nCols + colPadding, nChannels, nFilters, kernelSize, strides, n, _input, weights, bias)\n",
" return out, remainder"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"([[['-738206413373029545006965393527124494',\n",
" '-173320559228639935825945330543413025'],\n",
" ['-1034698083357167138897799627355946893',\n",
" '-434089078628623353676508551211157060'],\n",
" ['-830734559502817036444813835112148949',\n",
" '-686578771866623630758607927275546159'],\n",
" ['-285424960673894669036410085848276078',\n",
" '77035899885765 |
173133597720803628368'],\n",
" ['-41293201078409047199874417933080796',\n",
" '28777494655737863382696013669386951']],\n",
" [['-606713676308333020774846244444307246',\n",
" '388466467207809267549922375129065936'],\n",
" ['-1102737485952039787132334772316590877',\n",
" '711672842283067459049106389539428334'],\n",
" ['-1279246107747464951673577203827572661',\n",
" '-104057682619248993879676863654015882'],\n",
" ['-1137502411882990109129978808062308003',\n",
" '-285737283216816113761016693211231047'],\n",
" ['-703798773277911056745141956845225462',\n",
" '355407338114374779173330249858051758']],\n",
" [['-1546951103062535866431703941066730304',\n",
" '-509754977574520651977576289008629976'],\n",
" ['-2007190678249673958423804906616390874',\n",
" '-255124530399913653884258580354194679'],\n",
" ['-1987955686599915815112948301772925117',\n",
" '92785353760923841311068732708486389'],\n",
" ['-1501354303867896914042548115076362343',\n",
" '-140005761885967356612636419407991713'],\n",
" ['-758589315783580773280487949446211355',\n",
" '437520880361906870599644364227465106']],\n",
" [['-761417923444182653301008173638043967',\n",
" '91771720385437306243354293205033102'],\n",
" ['-1688165103880073226811051249397561256',\n",
" '-253090840416308272240635021911178871'],\n",
" ['-868411975706764838263900420928401111',\n",
" '427029536451544469306217379046517378'],\n",
" ['-1632207770832291707418877818442334628',\n",
" '313343146963309014974813849350304619'],\n",
" ['-1123607486465218134583708408995464790',\n",
" '277056825693143901704758542110909098']],\n",
" [['-543826042689234949496060048498817249',\n",
" '415061953419939109346123158429653654'],\n",
" ['-1006898403524974693098527575437710832',\n", |
" '646952095929760474345606121011841547'],\n",
" ['-1339156364320875137533821288468963984',\n",
" '424307047679243230200796457433761030'],\n",
" ['-633848388019879384336947814123500320',\n",
" '638133921526842615943818078787826079'],\n",
" ['-911192101070039979166490878519403558',\n",
" '572640728975516234503728848776059996']]],\n",
" [[['732636700329184288172821299452706816',\n",
" '163633766656393366871975061931163648'],\n",
" ['106376739450670706774435272610283520',\n",
" '224263678919132314456428282264944640'],\n",
" ['302563808180207575103565765357338624',\n",
" '724302115124451087131827274648649728'],\n",
" ['414653571797565705485911652130881536',\n",
" '793412538503882240528593488489480192'],\n",
" ['802744020509610387937821108140507136',\n",
" '304480836101726291197711385865748480']],\n",
" [['859770729700736535878340696623546368',\n",
" '892305185639885971968166660350672896'],\n",
" ['159017773966938546227144022541991936',\n",
" '243286973980475632014665402361577472'],\n",
" ['45707991996386548824583584683655168',\n",
" '305057405020119480420035216424304640'],\n",
" ['513655874550133048911800632902418432',\n",
" '966709976332017469863264280209522688'],\n",
" ['198125756383956075595551934970331136',\n",
" '988945351929415067553212891893071872']],\n",
" [['787267116688540528237625132699353088',\n",
" '820149329025927193528840575260819456'],\n",
" ['472980868351632170335228269959315456',\n",
" '763189020330031063201267188022378496'],\n",
" ['644197050565810210754859371753111552',\n",
" '989731482915520051484045079570546688'],\n",
" ['948204822800878014118539586611183616',\n",
" '748247265754602884949081086979211264'],\n",
" ['716169397100995271731495802811449344',\n",
" '4 |
85403242675801265137341039288254464']],\n",
" [['43352138962814326789218918981435392',\n",
" '405166142631707980272441068569493504'],\n",
" ['810091229170266512829629243259355136',\n",
" '269653910662555626980942633563586560'],\n",
" ['676839398629154231820514533721505792',\n",
" '419805522694742694500594416384737280'],\n",
" ['745383827341964610018052023030644736',\n",
" '256049836598014041054468595098058752'],\n",
" ['675940914936064095590762595072606208',\n",
" '261569026192941931124614732445646848']],\n",
" [['945584600952117166014909825389953024',\n",
" '419123852798410471873927944123449344'],\n",
" ['610870231548665514822003410375540736',\n",
" '444338394948450192884055088832708608'],\n",
" ['392811864299264176482313886100357120',\n",
" '482398655357498430014877178936688640'],\n",
" ['865948833234167064622566980785799168',\n",
" '886966130974971444248685772183437312'],\n",
" ['195220905237827872879130999353507840',\n",
" '356250510761353797733544351900893184']]])"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"out, remainder = Conv2DsameInt(5, 5, 3, 2, 3, 1, 10**36, X_in, weights, bias)\n",
"out, remainder"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"in_json = {\n",
" \"in\": X_in,\n",
" \"weights\": weights,\n",
" \"bias\": bias,\n",
" \"out\": out,\n",
" \"remainder\": remainder\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
" |
import json"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"with open(\"conv2Dsame_input.json\", \"w\") as f:\n",
" json.dump(in_json, f)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"inputs = Input(shape=(10,10,3))\n",
"x = Conv2D(2, 4, 3, padding=\"same\")(inputs)\n",
"model = Model(inputs, x)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: \"model_1\"\n",
"_________________________________________________________________\n",
" Layer (type) Output Shape Param
"=================================================================\n",
" input_2 (InputLayer) [(None, 10, 10, 3)] 0 \n",
" \n",
" conv2d_1 (Conv2D) (None, 4, 4, 2) 98 \n",
" \n",
"=================================================================\n",
"Total params: 98\n",
"Trainable params: 98\n",
"Non-trainable params: 0\n",
"_________________________________________________________________\n"
]
}
],
"source": [
"model.summary()"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[[[0.15917131, 0.77313235, 0.70732347],\n",
" [0.85210236, 0.77747055, 0.9126757 ],\n",
" [0.93479056, 0.819227 , 0.70156189],\n",
" [0.79143794, 0.87801591, 0.82904976],\n",
" [0.68619248, 0.52939185, 0.9781374 ],\n",
" [0.60719573, 0.89925314, 0.76945961],\n",
" [0.87552557, 0.90534932, 0.8788995 |
1],\n",
" [0.3906682 , 0.95580616, 0.31789736],\n",
" [0.76477277, 0.81754225, 0.69839668],\n",
" [0.83091809, 0.08929047, 0.41690024]],\n",
"\n",
" [[0.02156404, 0.1248342 , 0.10101914],\n",
" [0.89801399, 0.26753341, 0.07441736],\n",
" [0.02208311, 0.63957509, 0.89741475],\n",
" [0.34053784, 0.26694358, 0.75715605],\n",
" [0.53780638, 0.65565436, 0.91504456],\n",
" [0.25938895, 0.93164592, 0.89508771],\n",
" [0.59673249, 0.83579125, 0.43718874],\n",
" [0.15159799, 0.74559263, 0.75890839],\n",
" [0.14960964, 0.72981249, 0.3738258 ],\n",
" [0.77609438, 0.61152145, 0.26743727]],\n",
"\n",
" [[0.86386277, 0.08854458, 0.1881181 ],\n",
" [0.44605901, 0.5362032 , 0.35993523],\n",
" [0.30153601, 0.2052692 , 0.94686662],\n",
" [0.19258428, 0.29545743, 0.67123322],\n",
" [0.64059575, 0.25641094, 0.1195399 ],\n",
" [0.38441147, 0.12147883, 0.39661277],\n",
" [0.58068678, 0.99196337, 0.80942971],\n",
" [0.42854507, 0.58075105, 0.17898182],\n",
" [0.59835861, 0.53916735, 0.58269423],\n",
" [0.73442298, 0.50103808, 0.55618813]],\n",
"\n",
" [[0.70220035, 0.65299784, 0.06720906],\n",
" [0.98439586, 0.49217928, 0.29110757],\n",
" [0.40362701, 0.31214552, 0.33877257],\n",
" [0.63058855, 0.35760424, 0.46940153],\n",
" [0.13804137, 0.06058852, 0.55080509],\n",
" [0.76085309, 0.65603233, 0.76855789],\n",
" [0.82109332, 0.28625298, 0.5198722 ],\n",
" [0.52934891, 0.98676823, 0.45172351],\n",
" [0.26726209, 0.85657565, 0.95955236],\n",
" [0.19110728, 0.50206147, 0.05049411]],\n",
"\n",
" [[0.01880872, 0.25428 |
751, 0.32772514],\n",
" [0.1303663 , 0.75804367, 0.53268895],\n",
" [0.37711957, 0.72274233, 0.95032399],\n",
" [0.07563836, 0.93359311, 0.15796125],\n",
" [0.62045146, 0.64580923, 0.1557714 ],\n",
" [0.78905608, 0.85432612, 0.87425904],\n",
" [0.80316626, 0.51924423, 0.45801054],\n",
" [0.64371903, 0.55673077, 0.85455273],\n",
" [0.42522451, 0.75796177, 0.73794332],\n",
" [0.9042132 , 0.94432526, 0.84180072]],\n",
"\n",
" [[0.77346326, 0.84811549, 0.97897457],\n",
" [0.9229139 , 0.8745595 , 0.81151275],\n",
" [0.31466683, 0.22968788, 0.32937946],\n",
" [0.32265255, 0.60866667, 0.74966551],\n",
" [0.89690681, 0.22652098, 0.38790477],\n",
" [0.73330962, 0.60714074, 0.53581188],\n",
" [0.492162 , 0.4240943 , 0.7783657 ],\n",
" [0.0186855 , 0.69752848, 0.52908628],\n",
" [0.84273096, 0.30658396, 0.70465779],\n",
" [0.8684895 , 0.06929279, 0.73560357]],\n",
"\n",
" [[0.41183525, 0.06309388, 0.03012547],\n",
" [0.04789855, 0.39528684, 0.14238964],\n",
" [0.37892587, 0.73618744, 0.70410196],\n",
" [0.54405706, 0.07672244, 0.10798353],\n",
" [0.10530593, 0.46345768, 0.95231357],\n",
" [0.14640745, 0.47792646, 0.6955056 ],\n",
" [0.39633502, 0.68247493, 0.7154005 ],\n",
" [0.89354067, 0.92889669, 0.18524983],\n",
" [0.85684736, 0.40546574, 0.08902131],\n",
" [0.45694739, 0.57720739, 0.10578621]],\n",
"\n",
" [[0.36785594, 0.17667226, 0.46407189],\n",
" [0.11640223, 0.37587536, 0.93314522],\n",
" [0.03840141, 0.7311801 , 0.23603065],\n",
" [0.54117032, 0.85714659, 0.0495661 ],\n",
" [0.08494766, 0.87966 |
438, 0.37650164],\n",
" [0.95011446, 0.23333771, 0.26889821],\n",
" [0.86136317, 0.16072138, 0.03323276],\n",
" [0.31658215, 0.25675017, 0.59240392],\n",
" [0.07867128, 0.73161337, 0.96039619],\n",
" [0.95476936, 0.68330006, 0.99581875]],\n",
"\n",
" [[0.73541155, 0.30482595, 0.11167008],\n",
" [0.20315806, 0.45939058, 0.90883005],\n",
" [0.62037448, 0.07781508, 0.85993374],\n",
" [0.1662502 , 0.96140805, 0.4741485 ],\n",
" [0.10682937, 0.36184028, 0.52263044],\n",
" [0.55662028, 0.01836474, 0.90787543],\n",
" [0.79930707, 0.76048754, 0.12106902],\n",
" [0.45491329, 0.94061578, 0.48757815],\n",
" [0.12918205, 0.18806973, 0.58812925],\n",
" [0.80431 , 0.97299797, 0.05632223]],\n",
"\n",
" [[0.33911369, 0.9949053 , 0.61461519],\n",
" [0.78384667, 0.73316864, 0.85913351],\n",
" [0.38492166, 0.56317432, 0.59637715],\n",
" [0.3607973 , 0.05332751, 0.59008779],\n",
" [0.80225702, 0.88927018, 0.87653115],\n",
" [0.62173867, 0.62184283, 0.90795477],\n",
" [0.15894814, 0.54661812, 0.83119993],\n",
" [0.44861376, 0.28122679, 0.37193476],\n",
" [0.40747786, 0.24497888, 0.55174409],\n",
" [0.3188501 , 0.47713174, 0.23614857]]]])"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = np.random.rand(1,10,10,3)\n",
"X"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1/1 [==============================] - 0s 28ms/step\n"
]
},
{
"data": {
"text/plain": [
"array([[[[-0.811051 , -1.4721096 ],\n", |
" [-0.52853954, -0.47991082],\n",
" [-0.8595364 , -0.6705183 ],\n",
" [-0.07767564, -0.1320289 ]],\n",
"\n",
" [[-0.9737919 , -0.5298958 ],\n",
" [-1.0687585 , -0.33069813],\n",
" [-0.96858287, -0.61539143],\n",
" [-0.34952405, -0.3947128 ]],\n",
"\n",
" [[-1.1950083 , -0.39145365],\n",
" [-1.0355395 , 0.37544912],\n",
" [-0.46857417, -0.46149284],\n",
" [-0.1579878 , -0.14529735]],\n",
"\n",
" [[-0.7178327 , -0.6407934 ],\n",
" [-0.81823504, -0.48652953],\n",
" [-0.48897535, -0.5935499 ],\n",
" [-0.0888171 , -0.18892495]]]], dtype=float32)"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y = model.predict(X)\n",
"y"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"X_in = [[[int(X[0][i][j][k]*1e36) for k in range(3)] for j in range(10)] for i in range(10)]\n",
"weights = [[[[int(model.weights[0].numpy()[i][j][k][l]*1e36) for l in range(2)] for k in range(3)] for j in range(4)] for i in range(4)]\n",
"bias = [int(model.weights[1].numpy()[i]*1e72) for i in range(2)]"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"([[['-811051029307312151898080091259013408',\n",
" '-1472109697883872855085104222700990006'],\n",
" ['-528539552873451841296887387802887946',\n",
" '-479910753097361964472240108640655029'],\n",
" ['-859536355090285293603582494722226955',\n",
" '-670518221637687591501448018045711492'],\n",
" ['-77675673238639598916850751879067826',\n",
" '-132028915984577730731287477184728367']],\n",
" [['-973791923027617402137438972479106354',\n", |
" '-529895757470201620182206632643141082'],\n",
" ['-1068758558577939368141318995900977305',\n",
" '-330698196577790148366400564712521445'],\n",
" ['-968582927650604267027127767242160672',\n",
" '-615391447297339813950840270560399175'],\n",
" ['-349524047948521414307381813385449474',\n",
" '-394712802987869376369174007174918150']],\n",
" [['-1195008336948108945640918772722080227',\n",
" '-391453675833271485890705066425298906'],\n",
" ['-1035539474474336745928350434338370235',\n",
" '375449144451453718974060701074107917'],\n",
" ['-468574096206261610672918401549766744',\n",
" '-461492881731804944422419395904964084'],\n",
" ['-157987822858060281896825874562638157',\n",
" '-145297327207434479738146166840718303']],\n",
" [['-717832718354692660291274590189907309',\n",
" '-640793387586819749749055661801718428'],\n",
" ['-818234976163909363095633653303124629',\n",
" '-486529556567947364827511906932334658'],\n",
" ['-488975320390965478682141686514332960',\n",
" '-593549900211690891912136829366038418'],\n",
" ['-88817120440234533520269026413841619',\n",
" '-188924963686509380494214483287084738']]],\n",
" [[['57546413369690632436021828010377216',\n",
" '844338365610010970536479881582084096'],\n",
" ['713605335486457688719381102919155712',\n",
" '375215677051519710413966252668092416'],\n",
" ['755914587195177990836477246220271616',\n",
" '818027579922420637827386176052396032'],\n",
" ['66541310804045710582849369230278656',\n",
" '347409709477862532129959056406216704']],\n",
" [['289886146631823524117043901901045760',\n",
" '747073207457187946361744580709187584'],\n",
" ['596964332285599153985153944246026240',\n",
" '55475850457661407668048488535425024'],\n",
" ['1708343804086474706004984626098 |
99520',\n",
" '509441462772270674298218142377181184'],\n",
" ['34071275330636135911467390225874944',\n",
" '138225886497714127955769149616029696']],\n",
" [['799025578005122329965199425850572800',\n",
" '638105259408657768502010079451545600'],\n",
" ['646664651333832093639422680485593088',\n",
" '675100193761157594649844145046159360'],\n",
" ['445458083786331341876221205003894784',\n",
" '502163711096538860296377604167958528'],\n",
" ['47026304856349756806446693973229568',\n",
" '831593504386261794099030491582693376']],\n",
" [['939137107020160348118700928203227136',\n",
" '113237806886600667494639994056736768'],\n",
" ['659213932223174550761216604282814464',\n",
" '197300411875572149344585017353830400'],\n",
" ['421437083594697043343248459305058304',\n",
" '120269150227163283149044634810843136'],\n",
" ['198117022230724190125402300398698496',\n",
" '310521369112965179461249563143176192']]])"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"out, remainder = Conv2DsameInt(10, 10, 3, 2, 4, 3, 10**36, X_in, weights, bias)\n",
"out, remainder"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"in_json = {\n",
" \"in\": X_in,\n",
" \"weights\": weights,\n",
" \"bias\": bias,\n",
" \"out\": out,\n",
" \"remainder\": remainder\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"with open(\"conv2Dsame_stride_input.json\", \"w\") as f:\n",
" json.dump(in_json, f)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "sklearn",
"language": "pyt |
hon",
"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.9.13"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
} |
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"p = 21888242871839275222246405745257275088548364400416034343698204186575808495617"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"from tensorflow.keras.layers |
import Input, Dense\n",
"from tensorflow.keras |
import Model\n",
" |
import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"inputs = Input(shape=(20,))\n",
"out = Dense(10)(inputs)\n",
"model = Model(inputs, out)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: \"model\"\n",
"_________________________________________________________________\n",
" Layer (type) Output Shape Param
"=================================================================\n",
" input_1 (InputLayer) [(None, 20)] 0 \n",
" \n",
" dense (Dense) (None, 10) 210 \n",
" \n",
"=================================================================\n",
"Total params: 210\n",
"Trainable params: 210\n",
"Non-trainable params: 0\n",
"_________________________________________________________________\n"
]
}
],
"source": [
"model.summary()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.91709806, 0.82830839, 0.93914066, 0.57037095, 0.04271652,\n",
" 0.35534695, 0.29179199, 0.80227101, 0.65690956, 0.59359125,\n",
" 0.57083799, 0.64906287, 0.08615951, 0.20494363, 0.98687436,\n",
" 0.70022373, 0.8282763 , 0.38845018, 0.1025627 , 0.46584396]])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = np.random.rand(1,20)\n",
"X"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_typ |
e": "stream",
"text": [
"1/1 [==============================] - 0s 31ms/step\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2023-10-23 20:08:46.369862: W tensorflow/tsl/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
]
},
{
"data": {
"text/plain": [
"array([[-0.9478299 , -0.2901961 , 1.2173429 , 0.9856129 , 0.44817972,\n",
" 0.8500049 , 1.2243729 , 1.1230452 , -0.8100219 , 0.65824366]],\n",
" dtype=float32)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y = model.predict(X)\n",
"y"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"X_in = [int(x*1e36) for x in X[0]]\n",
"weights = [[None for _ in range(10)] for _ in range(20)]\n",
"for i in range(20):\n",
" for j in range(10):\n",
" weights[i][j] = int(model.get_weights()[0][i][j]*1e36)\n",
"bias = [int(b*1e72) for b in model.get_weights()[1]]"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def DenseInt(nInputs, nOutputs, n, input, weights, bias):\n",
" Input = [str(input[i] % p) for i in range(nInputs)]\n",
" Weights = [[str(weights[i][j] % p) for j in range(nOutputs)] for i in range(nInputs)]\n",
" Bias = [str(bias[i] % p) for i in range(nOutputs)]\n",
" out = [0 for _ in range(nOutputs)]\n",
" remainder = [None for _ in range(nOutputs)]\n",
" for j in range(nOutputs):\n",
" for i in range(nInputs):\n",
" out[j] += input[i] * weights[i][j]\n",
" out[j] += bias[j]\n",
" remainder[j] = str(out[j] % n)\n",
" out[j] = str(out[j]
" return Input, Weights, Bias, out, remainder\n",
" "
]
},
{
"cell_type": "code",
"execution_cou |
nt": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(['21888242871839275222246405745257275088547416570344934017690618098050994599407',\n",
" '21888242871839275222246405745257275088548074204322728883645171911568575253269',\n",
" '1217342773824182708964164664298235747',\n",
" '985612918881516198369842470059289901',\n",
" '448179765935532159653151439285979820',\n",
" '850005025728080684762697042708611430',\n",
" '1224373017260726380443809993782617513',\n",
" '1123045202502242457956309189904120564',\n",
" '21888242871839275222246405745257275088547554378545433689485043918282349046950',\n",
" '658243650814707862463466520227993190'],\n",
" ['51492294878586576180273547728388096',\n",
" '777789140836427041572477556551057408',\n",
" '890475291130181473765283908913463296',\n",
" '963682024802736049277914862344732672',\n",
" '180838407593997560156976766263492608',\n",
" '458215330546393498330258578539020288',\n",
" '738904904497555276279419263936102400',\n",
" '770453107465054933435045502301241344',\n",
" '616225701137188004915996184419500032',\n",
" '106851476518473341575934978717384704'])"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_in, weights, bias, out, remainder = DenseInt(20, 10, 10**36, X_in, weights, bias)\n",
"out, remainder"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"in_json = {\n",
" \"in\": X_in,\n",
" \"weights\": weights,\n",
" \"bias\": bias,\n",
" \"out\": out,\n",
" \"remainder\": remainder\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
" |
import json"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"with open(\"dense_input.json\", \"w\") as f:\n",
" json.dump(in_json, f)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "sklearn",
"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.9.16"
}
},
"nbformat": 4,
"nbformat_minor": 2
} |
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "4d60427f-21e9-41b1-a5eb-0d36d2c395ea",
"metadata": {},
"outputs": [],
"source": [
" |
import torch\n",
" |
import torch.nn as nn\n",
" |
import torch.nn.functional as F\n",
" |
import numpy as np\n",
" |
import json"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "b1962e3f-18b6-43b2-88f8-e81a49f4edbc",
"metadata": {},
"outputs": [],
"source": [
"p = 21888242871839275222246405745257275088548364400416034343698204186575808495617\n",
"CIRCOM_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617\n",
"MAX_POSITIVE = CIRCOM_PRIME
"MAX_NEGATIVE = MAX_POSITIVE + 1
"\n",
"EXPONENT = 15\n",
"\n",
"def from_circom(x):\n",
" if type(x) != int:\n",
" x = int(x)\n",
" if x > MAX_POSITIVE: \n",
" return x - CIRCOM_PRIME\n",
" return x\n",
" \n",
"def to_circom(x):\n",
" if type(x) != int:\n",
" x = int(x)\n",
" if x < 0:\n",
" return x + CIRCOM_PRIME \n",
" return x\n",
"\n",
" |
class SeparableConv2D(nn.Module):\n",
" '''Separable convolution'''\n",
" def __init__(self, in_channels, out_channels, stride=1):\n",
" super(SeparableConv2D, self).__init__()\n",
" self.dw_conv = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=stride, padding=1, groups=in_channels, bias=False)\n",
" self.pw_conv = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False)\n",
"\n",
" def forward(self, x):\n",
" x = self.dw_conv(x)\n",
" x = self.pw_conv(x)\n",
" return x"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "a7ad1f77-24e0-470e-b4de-63234ac9542b",
"metadata": {},
"outputs": [],
"source": [
"input = torch.randn((1, 3, 5, 5))\n",
"model = SeparableConv2D(3, 6)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "88e91743-d234-4e55-bd65-f4a5b0f5b350",
"metadata": {},
"outputs": [],
"source": [
"def DepthwiseConv(nRows, nCols, nChannels, nFilters, kernelSize, strides, n, input, weights, bias):\n",
" assert(nFilters % nChannels == 0)\n",
" outRows = (nRows - kernelSize)
" outCols = (nCols - kernelSize)
" \n",
"
" out = [[[0 for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
" remainder = [[[0 for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
"
" \n",
" for row in range(outRows):\n",
" for col in range(outCols):\n",
" for channel in range(nChannels):\n",
" for x in range(kernelSize):\n",
" for y in range(kernelSize):\n",
" out[row][col][channel] += int(input[row*strides+x, col*strides+y, channel]) * int(weights[x, y, channel])\n",
" \n",
" out[row][col][channel] += int(bias[channel])\n",
" remainder[row][col][channel] = str(int(o |
ut[row][col][channel] % n))\n",
" out[row][col][channel] = int(out[row][col][channel]
" \n",
" return out, remainder"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "e666c225-f618-43d4-b003-56f9b4699d2e",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"weights = model.dw_conv.weight.squeeze().detach().numpy()\n",
"bias = torch.zeros(weights.shape[0]).numpy()\n",
"\n",
"expected = model.dw_conv(input).detach().numpy()\n",
"\n",
"padded = F.pad(input, (1,1,1,1), \"constant\", 0)\n",
"padded = padded.squeeze().numpy().transpose((1, 2, 0))\n",
"weights = weights.transpose((1, 2, 0))\n",
"\n",
"quantized_image = padded * 10**EXPONENT\n",
"quantized_weights = weights * 10**EXPONENT\n",
"\n",
"actual, rem = DepthwiseConv(7, 7, 3, 3, 3, 1, 10**EXPONENT, quantized_image.round(), quantized_weights.round(), bias)\n",
"\n",
"expected = expected.squeeze().transpose((1, 2, 0))\n",
"expected = expected * 10**EXPONENT\n",
"\n",
"assert(np.allclose(expected, actual, atol=0.00001))"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "904ce6c4-f1d4-43f3-80f0-5e3df61d5546",
"metadata": {},
"outputs": [],
"source": [
"weights = model.dw_conv.weight.squeeze().detach().numpy()\n",
"bias = torch.zeros(weights.shape[0]).numpy()\n",
"\n",
"padded = F.pad(input, (1,1,1,1), \"constant\", 0)\n",
"padded = padded.squeeze().numpy().transpose((1, 2, 0))\n",
"weights = weights.transpose((1, 2, 0))\n",
"\n",
"quantized_image = padded * 10**EXPONENT\n",
"quantized_weights = weights * 10**EXPONENT\n",
"\n",
"out, remainder = DepthwiseConv(7, 7, 3, 3, 3, 1, 10**EXPONENT, quantized_image.round(), quantized_weights.round(), bias)\n",
"\n",
"circuit_in = quantized_image.round().astype(int).astype(str).tolist()\n",
"circuit_weights = quantized_weights.round().astype(int).astype(str).toli |
st()\n",
"circuit_bias = bias.round().astype(int).astype(str).tolist()\n",
"\n",
"input_json_path = \"depthwiseConv2D_input.json\"\n",
"with open(input_json_path, \"w\") as input_file:\n",
" json.dump({\"in\": circuit_in,\n",
" \"weights\": circuit_weights,\n",
" \"remainder\": remainder,\n",
" \"out\": out,\n",
" \"bias\": circuit_bias,\n",
" },\n",
" input_file)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "523588d7-4c81-4bb9-9dbd-e626b6d2a8a9",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.11.5"
}
},
"nbformat": 4,
"nbformat_minor": 5
} |
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from tensorflow.keras.layers |
import Input, Flatten\n",
"from tensorflow.keras |
import Model\n",
" |
import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"inputs = Input(shape=(5,5,3))\n",
"x = Flatten()(inputs)\n",
"model = Model(inputs, x)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: \"model\"\n",
"_________________________________________________________________\n",
" Layer (type) Output Shape Param
"=================================================================\n",
" input_1 (InputLayer) [(None, 5, 5, 3)] 0 \n",
" \n",
" flatten (Flatten) (None, 75) 0 \n",
" \n",
"=================================================================\n",
"Total params: 0\n",
"Trainable params: 0\n",
"Non-trainable params: 0\n",
"_________________________________________________________________\n"
]
}
],
"source": [
"model.summary()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.weights"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[[[0.9191584 , 0.41015604, 0.0493302 ],\n",
" [0.20412956, 0.14984944, 0.71595293],\n",
" [0.57980447, 0.28233206, 0.30881941],\n",
" [0.98703541, 0.91977126, 0.89591016],\n",
" [0.29365768, 0.89541076, 0.97098122]],\n",
"\n",
" [[0.28270309 |
, 0.85760979, 0.12266525],\n",
" [0.2386079 , 0.93741419, 0.83312648],\n",
" [0.02935679, 0.68497567, 0.37248647],\n",
" [0.76807667, 0.72347087, 0.84375984],\n",
" [0.89233681, 0.87703334, 0.53846864]],\n",
"\n",
" [[0.14028452, 0.61585222, 0.34271206],\n",
" [0.45404173, 0.26365195, 0.05140719],\n",
" [0.36253999, 0.51529482, 0.15006 ],\n",
" [0.82061228, 0.08937872, 0.65234282],\n",
" [0.31024437, 0.09785702, 0.40629764]],\n",
"\n",
" [[0.75192339, 0.55825739, 0.86978978],\n",
" [0.76105885, 0.54160411, 0.72517187],\n",
" [0.28701856, 0.31868524, 0.46890464],\n",
" [0.0902 , 0.3022873 , 0.48529066],\n",
" [0.24453082, 0.93271481, 0.08555694]],\n",
"\n",
" [[0.52171579, 0.22363436, 0.85212827],\n",
" [0.9823001 , 0.64424366, 0.96495129],\n",
" [0.61750385, 0.53921774, 0.75703119],\n",
" [0.57267588, 0.18643057, 0.26532282],\n",
" [0.22546175, 0.0340469 , 0.19259163]]]])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = np.random.rand(1,5,5,3)\n",
"X"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1/1 [==============================] - 0s 95ms/step\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2023-10-23 17:09:53.715790: W tensorflow/tsl/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
]
},
{
"data": {
"text/plain": [
"array([[0.9191584 , 0.41015604, 0.0493302 , 0.20412956, 0.14984943,\n",
" 0.71595293, 0.5798045 , 0.28233206, 0.3088194 , 0.9870354 ,\n",
" |
0.91977125, 0.89591014, 0.2936577 , 0.8954108 , 0.97098124,\n",
" 0.2827031 , 0.8576098 , 0.12266525, 0.2386079 , 0.93741417,\n",
" 0.8331265 , 0.02935679, 0.6849757 , 0.37248647, 0.76807666,\n",
" 0.72347087, 0.84375983, 0.8923368 , 0.87703335, 0.53846866,\n",
" 0.14028452, 0.61585224, 0.34271204, 0.45404172, 0.26365197,\n",
" 0.05140718, 0.36253998, 0.5152948 , 0.15006 , 0.82061225,\n",
" 0.08937872, 0.6523428 , 0.31024438, 0.09785703, 0.40629762,\n",
" 0.7519234 , 0.5582574 , 0.8697898 , 0.76105887, 0.5416041 ,\n",
" 0.72517186, 0.28701857, 0.31868523, 0.46890464, 0.0902 ,\n",
" 0.3022873 , 0.48529068, 0.24453081, 0.9327148 , 0.08555695,\n",
" 0.5217158 , 0.22363436, 0.85212827, 0.9823001 , 0.64424366,\n",
" 0.9649513 , 0.6175039 , 0.5392177 , 0.7570312 , 0.5726759 ,\n",
" 0.18643057, 0.26532283, 0.22546175, 0.0340469 , 0.19259164]],\n",
" dtype=float32)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y = model.predict(X)\n",
"y"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"in_json = {\n",
" \"in\": (X*1e36).round().astype(int).flatten().tolist(),\n",
" \"out\": (X*1e36).round().astype(int).flatten().tolist()\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
" |
import json"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"with open(\"flatten2D_input.json\", \"w\") as f:\n",
" json.dump(in_json, f)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "sklearn",
"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.9.16"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
} |
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"p = 21888242871839275222246405745257275088548364400416034343698204186575808495617"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"from tensorflow.keras.layers |
import Input, GlobalAveragePooling2D\n",
"from tensorflow.keras |
import Model\n",
" |
import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"inputs = Input(shape=(5,5,3))\n",
"out = GlobalAveragePooling2D()(inputs)\n",
"model = Model(inputs, out)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: \"model\"\n",
"_________________________________________________________________\n",
" Layer (type) Output Shape Param
"=================================================================\n",
" input_1 (InputLayer) [(None, 5, 5, 3)] 0 \n",
" \n",
" global_average_pooling2d (G (None, 3) 0 \n",
" lobalAveragePooling2D) \n",
" \n",
"=================================================================\n",
"Total params: 0\n",
"Trainable params: 0\n",
"Non-trainable params: 0\n",
"_________________________________________________________________\n"
]
}
],
"source": [
"model.summary()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[[[0.20867486, 0.38680755, 0.84218508],\n",
" [0.23655331, 0.33771458, 0.73516473],\n",
" [0.49345271, 0.95094652, 0.25402692],\n",
" [0.22771833, 0.97688694, 0.52917136],\n",
" [0.5871173 , 0.50441061, 0.97392083]],\n",
"\n",
" [[0.93934312, 0.52666508, 0.31051829],\n",
" [0.2163095 , 0.79177499, 0.3108483 ],\n",
" [0.53926143, 0.15753146, 0.99773704],\n",
" [0.12234007, 0.20568095, 0.11838809],\n |
",
" [0.9248088 , 0.52638782, 0.81404877]],\n",
"\n",
" [[0.01465677, 0.32765939, 0.74282836],\n",
" [0.6800781 , 0.40869424, 0.62145002],\n",
" [0.67374829, 0.81617885, 0.39987386],\n",
" [0.82099264, 0.35918735, 0.47107381],\n",
" [0.83104015, 0.83004572, 0.28737773]],\n",
"\n",
" [[0.74027671, 0.85697829, 0.49504698],\n",
" [0.94596904, 0.25070827, 0.22236492],\n",
" [0.00357426, 0.35882451, 0.32972314],\n",
" [0.57254891, 0.86380467, 0.30862848],\n",
" [0.93720522, 0.4496124 , 0.74115158]],\n",
"\n",
" [[0.12640468, 0.76330103, 0.35499368],\n",
" [0.37773597, 0.016954 , 0.43058637],\n",
" [0.94290805, 0.06019639, 0.95692684],\n",
" [0.09562172, 0.61791084, 0.47187214],\n",
" [0.67092949, 0.27421069, 0.85342606]]]])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = np.random.rand(1,5,5,3)\n",
"X"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1/1 [==============================] - 0s 36ms/step\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2023-10-23 20:10:13.674664: W tensorflow/tsl/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
]
},
{
"data": {
"text/plain": [
"array([[0.5171708 , 0.5047629 , 0.54293334]], dtype=float32)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y = model.predict(X)\n",
"y"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"X_in = [[[int(X[0][i] |
[j][k] * 1e36) for k in range(3)] for j in range(5)] for i in range(5)]"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def GlobalAveragePooling2DInt(nRows, nCols, nChannels, input):\n",
" Input = [[[str(input[i][j][k] % p) for k in range(nChannels)] for j in range(nCols)] for i in range(nRows)]\n",
" out = [0 for _ in range(nChannels)]\n",
" remainder = [None for _ in range(nChannels)]\n",
" for k in range(nChannels):\n",
" for i in range(nRows):\n",
" for j in range(nCols):\n",
" out[k] += input[i][j][k]\n",
" remainder[k] = str(out[k] % (nRows * nCols))\n",
" out[k] = str(out[k]
" return Input, out, remainder"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(['517170777415975145178424005003973754',\n",
" '504762926219743484887371893374996971',\n",
" '542933334573104965421804807186892718'],\n",
" ['22', '13', '2'])"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_in, out, remainder = GlobalAveragePooling2DInt(5, 5, 3, X_in)\n",
"out, remainder"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"in_json = {\n",
" \"in\": X_in,\n",
" \"out\": out,\n",
" \"remainder\": remainder\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
" |
import json"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"with open(\"globalAveragePooling2D_input.json\", \"w\") as f:\n",
" json.dump(in_json, f)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "sklearn",
"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.9.16"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
} |
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"p = 21888242871839275222246405745257275088548364400416034343698204186575808495617"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"from tensorflow.keras.layers |
import Input, GlobalMaxPooling2D\n",
"from tensorflow.keras |
import Model\n",
" |
import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"inputs = Input(shape=(5,5,3))\n",
"x = GlobalMaxPooling2D()(inputs)\n",
"model = Model(inputs, x)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: \"model\"\n",
"_________________________________________________________________\n",
" Layer (type) Output Shape Param
"=================================================================\n",
" input_1 (InputLayer) [(None, 5, 5, 3)] 0 \n",
" \n",
" global_max_pooling2d (Globa (None, 3) 0 \n",
" lMaxPooling2D) \n",
" \n",
"=================================================================\n",
"Total params: 0\n",
"Trainable params: 0\n",
"Non-trainable params: 0\n",
"_________________________________________________________________\n"
]
}
],
"source": [
"model.summary()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[[[0.91518641, 0.66718006, 0.92376279],\n",
" [0.97385149, 0.35848662, 0.25065166],\n",
" [0.02434808, 0.66270045, 0.51526436],\n",
" [0.97110905, 0.49335089, 0.27623285],\n",
" [0.88055993, 0.91070856, 0.89195416]],\n",
"\n",
" [[0.7950447 , 0.42411655, 0.66516519],\n",
" [0.18674268, 0.3046312 , 0.77807526],\n",
" [0.13333453, 0.68076544, 0.64069414],\n",
" [0.63039814, 0.71725918, 0.74384312],\n", |
" [0.48789065, 0.68079997, 0.25869622]],\n",
"\n",
" [[0.55852658, 0.78138444, 0.0772444 ],\n",
" [0.71960766, 0.01860611, 0.63859032],\n",
" [0.04100894, 0.007163 , 0.28648401],\n",
" [0.70371242, 0.8565901 , 0.73254654],\n",
" [0.35201173, 0.3338802 , 0.83269692]],\n",
"\n",
" [[0.31146493, 0.11242401, 0.46909255],\n",
" [0.785379 , 0.69905536, 0.99196427],\n",
" [0.29254832, 0.04347593, 0.40404928],\n",
" [0.64393514, 0.6579046 , 0.44890337],\n",
" [0.25879095, 0.64296721, 0.65792656]],\n",
"\n",
" [[0.7972691 , 0.77522241, 0.02028976],\n",
" [0.71408815, 0.2214879 , 0.07804482],\n",
" [0.65261239, 0.62851164, 0.12214903],\n",
" [0.31611407, 0.18022595, 0.97735959],\n",
" [0.57391523, 0.8818251 , 0.06020382]]]])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = np.random.rand(1,5,5,3)\n",
"X"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1/1 [==============================] - 0s 31ms/step\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2023-10-23 20:16:54.369715: W tensorflow/tsl/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
]
},
{
"data": {
"text/plain": [
"array([[0.9738515 , 0.91070855, 0.9919643 ]], dtype=float32)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y = model.predict(X)\n",
"y"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"X_in = [[[int(X[0][i][j][k]*1 |
e36) for k in range(3)] for j in range(5)] for i in range(5)]"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def GlobalMaxPooling2DInt(nRows, nCols, nChannels, input):\n",
" Input = [[[str(input[i][j][k] % p) for k in range(nChannels)] for j in range(nCols)] for i in range(nRows)]\n",
" out = [max(input[i][j][k] for i in range(nRows) for j in range(nCols)) for k in range(nChannels)]\n",
" return Input, out"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[973851490313537338484516198430015488,\n",
" 910708561343324144695836121136889856,\n",
" 991964273065568131927416012428804096]"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_in, out = GlobalMaxPooling2DInt(5,5,3,X_in)\n",
"out"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"in_json = {\n",
" \"in\": X_in,\n",
" \"out\": out\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
" |
import json"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"with open(\"globalMaxPooling2D_input.json\", \"w\") as f:\n",
" json.dump(in_json, f)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "sklearn",
"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.9.16"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
} |
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
" |
import pandas as pd\n",
"from sklearn.datasets |
import load_breast_cancer\n",
"from sklearn.model_selection |
import train_test_split\n",
"from sklearn.linear_model |
import LogisticRegression\n",
"from tensorflow.keras.models |
import Sequential\n",
"from tensorflow.keras.layers |
import InputLayer\n",
"from tensorflow.keras.layers |
import Dense\n",
" |
import tensorflow as tf"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>mean radius</th>\n",
" <th>mean texture</th>\n",
" <th>mean perimeter</th>\n",
" <th>mean area</th>\n",
" <th>mean smoothness</th>\n",
" <th>mean compactness</th>\n",
" <th>mean concavity</th>\n",
" <th>mean concave points</th>\n",
" <th>mean symmetry</th>\n",
" <th>mean fractal dimension</th>\n",
" <th>...</th>\n",
" <th>worst radius</th>\n",
" <th>worst texture</th>\n",
" <th>worst perimeter</th>\n",
" <th>worst area</th>\n",
" <th>worst smoothness</th>\n",
" <th>worst compactness</th>\n",
" <th>worst concavity</th>\n",
" <th>worst concave points</th>\n",
" <th>worst symmetry</th>\n",
" <th>worst fractal dimension</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>17.99</td>\n",
" <td>10.38</td>\n",
" <td>122.80</td>\n",
" <td>1001.0</td>\n",
" <td>0.11840</td>\n",
" <td>0.27760</td>\n",
" <td>0.3001</td>\n",
" <td>0.14710</td>\n",
" <td>0.2419</td>\n",
" |
<td>0.07871</td>\n",
" <td>...</td>\n",
" <td>25.38</td>\n",
" <td>17.33</td>\n",
" <td>184.60</td>\n",
" <td>2019.0</td>\n",
" <td>0.1622</td>\n",
" <td>0.6656</td>\n",
" <td>0.7119</td>\n",
" <td>0.2654</td>\n",
" <td>0.4601</td>\n",
" <td>0.11890</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20.57</td>\n",
" <td>17.77</td>\n",
" <td>132.90</td>\n",
" <td>1326.0</td>\n",
" <td>0.08474</td>\n",
" <td>0.07864</td>\n",
" <td>0.0869</td>\n",
" <td>0.07017</td>\n",
" <td>0.1812</td>\n",
" <td>0.05667</td>\n",
" <td>...</td>\n",
" <td>24.99</td>\n",
" <td>23.41</td>\n",
" <td>158.80</td>\n",
" <td>1956.0</td>\n",
" <td>0.1238</td>\n",
" <td>0.1866</td>\n",
" <td>0.2416</td>\n",
" <td>0.1860</td>\n",
" <td>0.2750</td>\n",
" <td>0.08902</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>19.69</td>\n",
" <td>21.25</td>\n",
" <td>130.00</td>\n",
" <td>1203.0</td>\n",
" <td>0.10960</td>\n",
" <td>0.15990</td>\n",
" <td>0.1974</td>\n",
" <td>0.12790</td>\n",
" <td>0.2069</td>\n",
" <td>0.05999</td>\n",
" <td>...</td>\n",
" <td>23.57</td>\n",
" <td>25.53</td>\n",
" <td>152.50</td>\n",
" <td>1709.0</td>\n",
" <td>0.1444</td>\n",
" <td>0.4245</td>\n",
" <td>0.4504</td>\n",
" <td>0.2430</td>\n",
" <td>0.3613</td>\n",
" <td>0.08758</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" < |
td>11.42</td>\n",
" <td>20.38</td>\n",
" <td>77.58</td>\n",
" <td>386.1</td>\n",
" <td>0.14250</td>\n",
" <td>0.28390</td>\n",
" <td>0.2414</td>\n",
" <td>0.10520</td>\n",
" <td>0.2597</td>\n",
" <td>0.09744</td>\n",
" <td>...</td>\n",
" <td>14.91</td>\n",
" <td>26.50</td>\n",
" <td>98.87</td>\n",
" <td>567.7</td>\n",
" <td>0.2098</td>\n",
" <td>0.8663</td>\n",
" <td>0.6869</td>\n",
" <td>0.2575</td>\n",
" <td>0.6638</td>\n",
" <td>0.17300</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>20.29</td>\n",
" <td>14.34</td>\n",
" <td>135.10</td>\n",
" <td>1297.0</td>\n",
" <td>0.10030</td>\n",
" <td>0.13280</td>\n",
" <td>0.1980</td>\n",
" <td>0.10430</td>\n",
" <td>0.1809</td>\n",
" <td>0.05883</td>\n",
" <td>...</td>\n",
" <td>22.54</td>\n",
" <td>16.67</td>\n",
" <td>152.20</td>\n",
" <td>1575.0</td>\n",
" <td>0.1374</td>\n",
" <td>0.2050</td>\n",
" <td>0.4000</td>\n",
" <td>0.1625</td>\n",
" <td>0.2364</td>\n",
" <td>0.07678</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"<p>5 rows × 30 columns</p>\n",
"</div>"
],
"text/plain": [
" mean radius mean texture mean perimeter mean area mean smoothness \\\n",
"0 17.99 10.38 122.80 1001.0 0.11840 \n",
"1 20.57 17.77 132.90 1326.0 0.08474 \n",
"2 19.69 21.25 130.00 1203.0 0.10960 \n",
"3 11.42 20.38 77.58 386.1 |
0.14250 \n",
"4 20.29 14.34 135.10 1297.0 0.10030 \n",
"\n",
" mean compactness mean concavity mean concave points mean symmetry \\\n",
"0 0.27760 0.3001 0.14710 0.2419 \n",
"1 0.07864 0.0869 0.07017 0.1812 \n",
"2 0.15990 0.1974 0.12790 0.2069 \n",
"3 0.28390 0.2414 0.10520 0.2597 \n",
"4 0.13280 0.1980 0.10430 0.1809 \n",
"\n",
" mean fractal dimension ... worst radius worst texture worst perimeter \\\n",
"0 0.07871 ... 25.38 17.33 184.60 \n",
"1 0.05667 ... 24.99 23.41 158.80 \n",
"2 0.05999 ... 23.57 25.53 152.50 \n",
"3 0.09744 ... 14.91 26.50 98.87 \n",
"4 0.05883 ... 22.54 16.67 152.20 \n",
"\n",
" worst area worst smoothness worst compactness worst concavity \\\n",
"0 2019.0 0.1622 0.6656 0.7119 \n",
"1 1956.0 0.1238 0.1866 0.2416 \n",
"2 1709.0 0.1444 0.4245 0.4504 \n",
"3 567.7 0.2098 0.8663 0.6869 \n",
"4 1575.0 0.1374 0.2050 0.4000 \n",
"\n",
" worst concave points worst symmetry worst fractal dimension \n",
"0 0.2654 0.4601 0.11890 \n",
"1 0.1860 0.2750 0.08902 \n",
"2 0.2430 0.3613 0.08758 |
\n",
"3 0.2575 0.6638 0.17300 \n",
"4 0.1625 0.2364 0.07678 \n",
"\n",
"[5 rows x 30 columns]"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"cancer = load_breast_cancer()\n",
"df = pd.DataFrame(cancer.data,\n",
" columns=cancer.feature_names)\n",
"df.head()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"X = (df-df.mean())/df.std()\n",
"
"
"y = pd.Series(cancer.target)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"
"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, \n",
" shuffle=True, random_state=2)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Accuracy: 0.97\n",
"Precision: 0.99\n",
"Recall: 0.97\n",
"F-Score: 0.98\n"
]
}
],
"source": [
"
"log_reg_model = LogisticRegression(max_iter=2500,\n",
" random_state=42)\n",
"\n",
"
"log_reg_model.fit(X_train, y_train)\n",
"\n",
"
"y_pred = log_reg_model.predict(X_test)
"y_true = y_test
"\n",
"
"from sklearn.metrics |
import accuracy_score\n",
"from sklearn.metrics |
import precision_recall_fscore_support\n",
" |
import numpy as np\n",
"\n",
"print(\"Accuracy:\", np.round(accuracy_score(y_true, y_pred), 2))\n",
"precision, recall, fscore, _ = precision_recall_fscore_support(y_true, y_pred,\n",
" average='binary')\n",
"print(\"Precision:\", np.round(precision, 2))\n",
"print(\"Recall:\", np.round(recall, 2))\n",
"print(\"F-Score:\", np.round(fscore, 2))"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"model = Sequential()\n",
"\n",
"model.add(InputLayer(input_shape=(30, )))\n",
"
"model.add(Dense(1, activation='tanh'))\n",
"\n",
"optimizer=tf.keras.optimizers.legacy.Adam(learning_rate=0.05)\n",
"model.compile(optimizer=optimizer,\n",
" loss='binary_crossentropy',\n",
" metrics=['accuracy'])"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/10\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2023-10-12 14:44:16.741589: W tensorflow/tsl/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"12/12 [==============================] - 0s 12ms/step - loss: 2.0170 - accuracy: 0.7747 - val_loss: 0.9741 - val_accuracy: 0.8901\n",
"Epoch 2/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 1.0516 - accuracy: 0.8929 - val_loss: 0.7816 - val_accuracy: 0.9011\n",
"Epoch 3/10\n",
"12/12 [==============================] - 0s 2ms/step - loss: 0.8193 - accuracy: 0.9093 - val_loss: 0.7534 - val_accuracy: 0.9121\n",
"Epoch 4/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.6689 - accuracy: 0.9341 - val_loss: 0.7462 - val_accuracy: 0.9121\n", |
"Epoch 5/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.6168 - accuracy: 0.9423 - val_loss: 0.7404 - val_accuracy: 0.9231\n",
"Epoch 6/10\n",
"12/12 [==============================] - 0s 2ms/step - loss: 0.3145 - accuracy: 0.9560 - val_loss: 0.2055 - val_accuracy: 0.9670\n",
"Epoch 7/10\n",
"12/12 [==============================] - 0s 2ms/step - loss: 0.2109 - accuracy: 0.9505 - val_loss: 0.2063 - val_accuracy: 0.9670\n",
"Epoch 8/10\n",
"12/12 [==============================] - 0s 2ms/step - loss: 0.1104 - accuracy: 0.9670 - val_loss: 0.0447 - val_accuracy: 0.9780\n",
"Epoch 9/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.0851 - accuracy: 0.9698 - val_loss: 0.0443 - val_accuracy: 0.9780\n",
"Epoch 10/10\n",
"12/12 [==============================] - 0s 2ms/step - loss: 0.0745 - accuracy: 0.9698 - val_loss: 0.0453 - val_accuracy: 0.9670\n"
]
},
{
"data": {
"text/plain": [
"<keras.callbacks.History at 0x15fd9eeb0>"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.fit(X_train, y_train,\n",
" epochs=10, batch_size=32,\n",
" validation_split=0.2,\n",
" shuffle=False)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4/4 [==============================] - 0s 1ms/step - loss: 0.4077 - accuracy: 0.9474\n",
"Test loss: 0.4076523780822754\n",
"Test accuracy: 0.9473684430122375\n"
]
}
],
"source": [
"test_loss, test_acc = model.evaluate(X_test, y_test)\n",
"print(\"Test loss:\", test_loss)\n",
"print(\"Test accuracy:\", test_acc)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"def zanh(x):\n",
" retur |
n 0.006769816 + 0.554670504 * x - 0.009411195 * x**2 - 0.014187547 * x**3\n",
"\n",
"zanh_model = Sequential()\n",
"\n",
"zanh_model.add(InputLayer(input_shape=(30, )))\n",
"
"zanh_model.add(Dense(1, activation=zanh))\n",
"\n",
"optimizer=tf.keras.optimizers.legacy.Adam(learning_rate=0.05)\n",
"zanh_model.compile(optimizer=optimizer,\n",
" loss='binary_crossentropy',\n",
" metrics=['accuracy'])"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/10\n",
"12/12 [==============================] - 0s 12ms/step - loss: 2.7550 - accuracy: 0.6978 - val_loss: 1.5429 - val_accuracy: 0.7912\n",
"Epoch 2/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 1.5446 - accuracy: 0.8297 - val_loss: 0.5988 - val_accuracy: 0.9341\n",
"Epoch 3/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.6857 - accuracy: 0.8791 - val_loss: 0.1382 - val_accuracy: 0.9670\n",
"Epoch 4/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.2950 - accuracy: 0.9258 - val_loss: 0.1452 - val_accuracy: 0.9451\n",
"Epoch 5/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.2493 - accuracy: 0.9478 - val_loss: 0.1188 - val_accuracy: 0.9670\n",
"Epoch 6/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.1930 - accuracy: 0.9588 - val_loss: 0.1023 - val_accuracy: 0.9670\n",
"Epoch 7/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.1749 - accuracy: 0.9643 - val_loss: 0.0879 - val_accuracy: 0.9670\n",
"Epoch 8/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.1841 - accuracy: 0.9643 - val_loss: 0.0996 - val_accuracy: 0.9780\n",
"Epoch 9/10\n",
"12/12 [==============================] - 0s 2ms/step - loss: 0.1695 - ac |
curacy: 0.9670 - val_loss: 0.0836 - val_accuracy: 0.9670\n",
"Epoch 10/10\n",
"12/12 [==============================] - 0s 2ms/step - loss: 0.2076 - accuracy: 0.9588 - val_loss: 0.0839 - val_accuracy: 0.9780\n"
]
},
{
"data": {
"text/plain": [
"<keras.callbacks.History at 0x15ff92ca0>"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"zanh_model.fit(X_train, y_train,\n",
" epochs=10, batch_size=32,\n",
" validation_split=0.2,\n",
" shuffle=False)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4/4 [==============================] - 0s 1ms/step - loss: 0.2434 - accuracy: 0.9649\n",
"Test loss: 0.24344508349895477\n",
"Test accuracy: 0.9649122953414917\n"
]
}
],
"source": [
"test_loss, test_acc = zanh_model.evaluate(X_test, y_test)\n",
"print(\"Test loss:\", test_loss)\n",
"print(\"Test accuracy:\", test_acc)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "sklearn",
"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.9.16"
}
},
"nbformat": 4,
"nbformat_minor": 2
} |
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
" |
import pandas as pd\n",
"from sklearn.datasets |
import load_breast_cancer\n",
"from sklearn.model_selection |
import train_test_split\n",
"from sklearn.linear_model |
import LogisticRegression\n",
"from tensorflow.keras.models |
import Sequential\n",
"from tensorflow.keras.layers |
import InputLayer\n",
"from tensorflow.keras.layers |
import Dense\n",
" |
import tensorflow as tf"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>mean radius</th>\n",
" <th>mean texture</th>\n",
" <th>mean perimeter</th>\n",
" <th>mean area</th>\n",
" <th>mean smoothness</th>\n",
" <th>mean compactness</th>\n",
" <th>mean concavity</th>\n",
" <th>mean concave points</th>\n",
" <th>mean symmetry</th>\n",
" <th>mean fractal dimension</th>\n",
" <th>...</th>\n",
" <th>worst radius</th>\n",
" <th>worst texture</th>\n",
" <th>worst perimeter</th>\n",
" <th>worst area</th>\n",
" <th>worst smoothness</th>\n",
" <th>worst compactness</th>\n",
" <th>worst concavity</th>\n",
" <th>worst concave points</th>\n",
" <th>worst symmetry</th>\n",
" <th>worst fractal dimension</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>17.99</td>\n",
" <td>10.38</td>\n",
" <td>122.80</td>\n",
" <td>1001.0</td>\n",
" <td>0.11840</td>\n",
" <td>0.27760</td>\n",
" <td>0.3001</td>\n",
" <td>0.14710</td>\n",
" <td>0.2419</td>\n",
" |
<td>0.07871</td>\n",
" <td>...</td>\n",
" <td>25.38</td>\n",
" <td>17.33</td>\n",
" <td>184.60</td>\n",
" <td>2019.0</td>\n",
" <td>0.1622</td>\n",
" <td>0.6656</td>\n",
" <td>0.7119</td>\n",
" <td>0.2654</td>\n",
" <td>0.4601</td>\n",
" <td>0.11890</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20.57</td>\n",
" <td>17.77</td>\n",
" <td>132.90</td>\n",
" <td>1326.0</td>\n",
" <td>0.08474</td>\n",
" <td>0.07864</td>\n",
" <td>0.0869</td>\n",
" <td>0.07017</td>\n",
" <td>0.1812</td>\n",
" <td>0.05667</td>\n",
" <td>...</td>\n",
" <td>24.99</td>\n",
" <td>23.41</td>\n",
" <td>158.80</td>\n",
" <td>1956.0</td>\n",
" <td>0.1238</td>\n",
" <td>0.1866</td>\n",
" <td>0.2416</td>\n",
" <td>0.1860</td>\n",
" <td>0.2750</td>\n",
" <td>0.08902</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>19.69</td>\n",
" <td>21.25</td>\n",
" <td>130.00</td>\n",
" <td>1203.0</td>\n",
" <td>0.10960</td>\n",
" <td>0.15990</td>\n",
" <td>0.1974</td>\n",
" <td>0.12790</td>\n",
" <td>0.2069</td>\n",
" <td>0.05999</td>\n",
" <td>...</td>\n",
" <td>23.57</td>\n",
" <td>25.53</td>\n",
" <td>152.50</td>\n",
" <td>1709.0</td>\n",
" <td>0.1444</td>\n",
" <td>0.4245</td>\n",
" <td>0.4504</td>\n",
" <td>0.2430</td>\n",
" <td>0.3613</td>\n",
" <td>0.08758</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" < |
td>11.42</td>\n",
" <td>20.38</td>\n",
" <td>77.58</td>\n",
" <td>386.1</td>\n",
" <td>0.14250</td>\n",
" <td>0.28390</td>\n",
" <td>0.2414</td>\n",
" <td>0.10520</td>\n",
" <td>0.2597</td>\n",
" <td>0.09744</td>\n",
" <td>...</td>\n",
" <td>14.91</td>\n",
" <td>26.50</td>\n",
" <td>98.87</td>\n",
" <td>567.7</td>\n",
" <td>0.2098</td>\n",
" <td>0.8663</td>\n",
" <td>0.6869</td>\n",
" <td>0.2575</td>\n",
" <td>0.6638</td>\n",
" <td>0.17300</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>20.29</td>\n",
" <td>14.34</td>\n",
" <td>135.10</td>\n",
" <td>1297.0</td>\n",
" <td>0.10030</td>\n",
" <td>0.13280</td>\n",
" <td>0.1980</td>\n",
" <td>0.10430</td>\n",
" <td>0.1809</td>\n",
" <td>0.05883</td>\n",
" <td>...</td>\n",
" <td>22.54</td>\n",
" <td>16.67</td>\n",
" <td>152.20</td>\n",
" <td>1575.0</td>\n",
" <td>0.1374</td>\n",
" <td>0.2050</td>\n",
" <td>0.4000</td>\n",
" <td>0.1625</td>\n",
" <td>0.2364</td>\n",
" <td>0.07678</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"<p>5 rows × 30 columns</p>\n",
"</div>"
],
"text/plain": [
" mean radius mean texture mean perimeter mean area mean smoothness \\\n",
"0 17.99 10.38 122.80 1001.0 0.11840 \n",
"1 20.57 17.77 132.90 1326.0 0.08474 \n",
"2 19.69 21.25 130.00 1203.0 0.10960 \n",
"3 11.42 20.38 77.58 386.1 |
0.14250 \n",
"4 20.29 14.34 135.10 1297.0 0.10030 \n",
"\n",
" mean compactness mean concavity mean concave points mean symmetry \\\n",
"0 0.27760 0.3001 0.14710 0.2419 \n",
"1 0.07864 0.0869 0.07017 0.1812 \n",
"2 0.15990 0.1974 0.12790 0.2069 \n",
"3 0.28390 0.2414 0.10520 0.2597 \n",
"4 0.13280 0.1980 0.10430 0.1809 \n",
"\n",
" mean fractal dimension ... worst radius worst texture worst perimeter \\\n",
"0 0.07871 ... 25.38 17.33 184.60 \n",
"1 0.05667 ... 24.99 23.41 158.80 \n",
"2 0.05999 ... 23.57 25.53 152.50 \n",
"3 0.09744 ... 14.91 26.50 98.87 \n",
"4 0.05883 ... 22.54 16.67 152.20 \n",
"\n",
" worst area worst smoothness worst compactness worst concavity \\\n",
"0 2019.0 0.1622 0.6656 0.7119 \n",
"1 1956.0 0.1238 0.1866 0.2416 \n",
"2 1709.0 0.1444 0.4245 0.4504 \n",
"3 567.7 0.2098 0.8663 0.6869 \n",
"4 1575.0 0.1374 0.2050 0.4000 \n",
"\n",
" worst concave points worst symmetry worst fractal dimension \n",
"0 0.2654 0.4601 0.11890 \n",
"1 0.1860 0.2750 0.08902 \n",
"2 0.2430 0.3613 0.08758 |
\n",
"3 0.2575 0.6638 0.17300 \n",
"4 0.1625 0.2364 0.07678 \n",
"\n",
"[5 rows x 30 columns]"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"cancer = load_breast_cancer()\n",
"df = pd.DataFrame(cancer.data,\n",
" columns=cancer.feature_names)\n",
"df.head()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"X = (df-df.mean())/df.std()\n",
"
"
"y = pd.Series(cancer.target)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, \n",
" shuffle=True, random_state=2)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Accuracy: 0.97\n",
"Precision: 0.99\n",
"Recall: 0.97\n",
"F-Score: 0.98\n"
]
}
],
"source": [
"
"log_reg_model = LogisticRegression(max_iter=2500,\n",
" random_state=42)\n",
"\n",
"
"log_reg_model.fit(X_train, y_train)\n",
"\n",
"
"y_pred = log_reg_model.predict(X_test)
"y_true = y_test
"\n",
"
"from sklearn.metrics |
import accuracy_score\n",
"from sklearn.metrics |
import precision_recall_fscore_support\n",
" |
import numpy as np\n",
"\n",
"print(\"Accuracy:\", np.round(accuracy_score(y_true, y_pred), 2))\n",
"precision, recall, fscore, _ = precision_recall_fscore_support(y_true, y_pred,\n",
" average='binary')\n",
"print(\"Precision:\", np.round(precision, 2))\n",
"print(\"Recall:\", np.round(recall, 2))\n",
"print(\"F-Score:\", np.round(fscore, 2))"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"model = Sequential()\n",
"\n",
"model.add(InputLayer(input_shape=(30, )))\n",
"
"model.add(Dense(1, activation='sigmoid'))\n",
"\n",
"optimizer=tf.keras.optimizers.legacy.Adam(learning_rate=0.05)\n",
"model.compile(optimizer=optimizer,\n",
" loss='binary_crossentropy',\n",
" metrics=['accuracy'])"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/10\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2023-10-12 14:37:31.395427: W tensorflow/tsl/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"12/12 [==============================] - 0s 15ms/step - loss: 0.3646 - accuracy: 0.8407 - val_loss: 0.1326 - val_accuracy: 0.9341\n",
"Epoch 2/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.0995 - accuracy: 0.9643 - val_loss: 0.0896 - val_accuracy: 0.9560\n",
"Epoch 3/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.0793 - accuracy: 0.9808 - val_loss: 0.0776 - val_accuracy: 0.9670\n",
"Epoch 4/10\n",
"12/12 [==============================] - 0s 3ms/step - loss: 0.0734 - accuracy: 0.9808 - val_loss: 0.0749 - val_accuracy: 0.9560\ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.