github/circomlib-ml
1
1
Fork 0
mirror of https://github.com/socathie/circomlib-ml.git synced 2026-01-09 14:08:04 -05:00
Code Issues Packages Projects Releases Wiki Activity

Add separable convolution circuit implementation (#7)

Browse Source 
* add circuits and tests for separable convolution. Circuits do not yet comply with repo`s quantization

* make depthwise circuit compliant with quantization method from repo

* make pointwise circuit compliant with quantization method from repo

* separable convolution test works

* clean up

* fix typos and skip failing test

* clean up duplicated code for depthwise conv

* clean up duplicated code for pointwise conv

* clean up duplicated code for separable conv notebook

* chore: update filename to capital case

---------

Co-authored-by: drCathieSo.eth <socathie@users.noreply.github.com>
This commit is contained in:
Semar Augusto
2023-11-26 07:53:14 -03:00
committed by GitHub
parent 09b0949569
commit 418917338a
21 changed files with 1301 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
circuits/DepthwiseConv2D.circom Normal file
View File

@@ -0,0 +1,64 @@
pragma circom 2.1.1;
// include "./Conv2D.circom";
include "./circomlib/sign.circom";
include "./circomlib/bitify.circom";
include "./circomlib/comparators.circom";
include "./circomlib-matrix/matElemMul.circom";
include "./circomlib-matrix/matElemSum.circom";
include "./util.circom";
// Depthwise Convolution layer with valid padding
// Note that nFilters must be a multiple of nChannels
// n = 10 to the power of the number of decimal places
// component main = DepthwiseConv2D(34, 34, 8, 8, 3, 1);
template DepthwiseConv2D (nRows, nCols, nChannels, nFilters, kernelSize, strides, n) {
var outRows = (nRows-kernelSize)\strides+1;
var outCols = (nCols-kernelSize)\strides+1;
signal input in[nRows][nCols][nChannels];
signal input weights[kernelSize][kernelSize][nFilters]; // weights are 3d because depth is 1
signal input bias[nFilters];
signal input remainder[outRows][outCols][nFilters];
signal input out[outRows][outCols][nFilters];
component mul[outRows][outCols][nFilters];
component elemSum[outRows][outCols][nFilters];
var valid_groups = nFilters % nChannels;
var filtersPerChannel = nFilters / nChannels;
signal groups;
groups <== valid_groups;
component is_zero = IsZero();
is_zero.in <== groups;
is_zero.out === 1;
for (var row=0; row<outRows; row++) {
for (var col=0; col<outCols; col++) {
for (var filterMultiplier=1; filterMultiplier<=filtersPerChannel; filterMultiplier++) {
for (var channel=0; channel<nChannels; channel++) {
var filter = filterMultiplier*channel;
mul[row][col][filter] = matElemMul(kernelSize,kernelSize);
for (var x=0; x<kernelSize; x++) {
for (var y=0; y<kernelSize; y++) {
mul[row][col][filter].a[x][y] <== in[row*strides+x][col*strides+y][channel];
mul[row][col][filter].b[x][y] <== weights[x][y][filter];
}
}
elemSum[row][col][filter] = matElemSum(kernelSize,kernelSize);
for (var x=0; x<kernelSize; x++) {
for (var y=0; y<kernelSize; y++) {
elemSum[row][col][filter].a[x][y] <== mul[row][col][filter].out[x][y];
}
}
out[row][col][filter] * n + remainder[row][col][filter] === elemSum[row][col][filter].out + bias[filter];
}
}
}
}
}

39
circuits/PointwiseConv2D.circom Normal file
View File

@@ -0,0 +1,39 @@
pragma circom 2.1.1;
// include "./Conv2D.circom";
include "./circomlib/sign.circom";
include "./circomlib/bitify.circom";
include "./circomlib/comparators.circom";
include "./circomlib-matrix/matElemMul.circom";
include "./circomlib-matrix/matElemSum.circom";
include "./util.circom";
// Pointwise Convolution layer
// Note that nFilters must be a multiple of nChannels
template PointwiseConv2D (nRows, nCols, nChannels, nFilters, n) {
var outRows = nRows; // kernel size and strides are 1
var outCols = nCols;
signal input in[nRows][nCols][nChannels];
signal input weights[nChannels][nFilters]; // weights are 2d because kernel_size is 1
signal input bias[nFilters];
signal input out[outRows][outCols][nFilters];
signal input remainder[outRows][outCols][nFilters];
component sum[outRows][outCols][nFilters];
for (var row=0; row<outRows; row++) {
for (var col=0; col<outCols; col++) {
for (var filter=0; filter<nFilters; filter++) {
sum[row][col][filter] = Sum(nChannels);
for (var channel=0; channel<nChannels; channel++) {
sum[row][col][filter].in[channel] <== in[row][col][channel] * weights[channel][filter];
}
out[row][col][filter] * n + remainder[row][col][filter] === sum[row][col][filter].out + bias[filter];
}
}
}
}
// component main = PointwiseConv2D(32, 32, 8, 16);

67
circuits/SeparableConv2D.circom Normal file
View File

@@ -0,0 +1,67 @@
pragma circom 2.1.1;
include "./PointwiseConv2D.circom";
include "./DepthwiseConv2D.circom";
// Separable convolution layer with valid padding.
// Quantization is done by the caller by multiplying float values by 10**exp.
template SeparableConv2D (nRows, nCols, nChannels, nDepthFilters, nPointFilters, depthKernelSize, strides, n) {
var outRows = (nRows-depthKernelSize)\strides+1;
var outCols = (nCols-depthKernelSize)\strides+1;
signal input in[nRows][nCols][nChannels];
signal input depthWeights[depthKernelSize][depthKernelSize][nDepthFilters]; // weights are 3d because depth is 1
signal input depthBias[nDepthFilters];
signal input depthRemainder[outRows][outCols][nDepthFilters];
signal input depthOut[outRows][outCols][nDepthFilters];
signal input pointWeights[nChannels][nPointFilters]; // weights are 2d because depthKernelSize is one
signal input pointBias[nPointFilters];
signal input pointRemainder[outRows][outCols][nPointFilters];
signal input pointOut[outRows][outCols][nPointFilters];
component depthConv = DepthwiseConv2D(nRows, nCols, nChannels, nDepthFilters, depthKernelSize, strides, n);
component pointConv = PointwiseConv2D(outRows, outCols, nDepthFilters, nPointFilters, n);
for (var filter=0; filter<nDepthFilters; filter++) {
for (var x=0; x<depthKernelSize; x++) {
for (var y=0; y<depthKernelSize; y++) {
depthConv.weights[x][y][filter] <== depthWeights[x][y][filter];
}
}
depthConv.bias[filter] <== depthBias[filter];
}
for (var row=0; row < nRows; row++) {
for (var col=0; col < nCols; col++) {
for (var channel=0; channel < nChannels; channel++) {
depthConv.in[row][col][channel] <== in[row][col][channel];
}
}
}
for (var row=0; row < outRows; row++) {
for (var col=0; col < outCols; col++) {
for (var filter=0; filter < nDepthFilters; filter++) {
depthConv.remainder[row][col][filter] <== depthRemainder[row][col][filter];
depthConv.out[row][col][filter] <== depthOut[row][col][filter];
pointConv.in[row][col][filter] <== depthOut[row][col][filter];
}
}
}
for (var filter=0; filter < nPointFilters; filter++) {
for (var channel=0; channel < nChannels; channel++) {
pointConv.weights[channel][filter] <== pointWeights[channel][filter];
}
pointConv.bias[filter] <== pointBias[filter];
}
for (var row=0; row < outRows; row++) {
for (var col=0; col < outCols; col++) {
for (var filter=0; filter < nPointFilters; filter++) {
pointConv.remainder[row][col][filter] <== pointRemainder[row][col][filter];
pointConv.out[row][col][filter] <== pointOut[row][col][filter];
}
}
}
}

64
circuits/depthwiseConv2D.circom Normal file
View File

@@ -0,0 +1,64 @@
pragma circom 2.1.1;
// include "./Conv2D.circom";
include "./circomlib/sign.circom";
include "./circomlib/bitify.circom";
include "./circomlib/comparators.circom";
include "./circomlib-matrix/matElemMul.circom";
include "./circomlib-matrix/matElemSum.circom";
include "./util.circom";
// Depthwise Convolution layer with valid padding
// Note that nFilters must be a multiple of nChannels
// n = 10 to the power of the number of decimal places
// component main = DepthwiseConv2D(34, 34, 8, 8, 3, 1);
template DepthwiseConv2D (nRows, nCols, nChannels, nFilters, kernelSize, strides, n) {
var outRows = (nRows-kernelSize)\strides+1;
var outCols = (nCols-kernelSize)\strides+1;
signal input in[nRows][nCols][nChannels];
signal input weights[kernelSize][kernelSize][nFilters]; // weights are 3d because depth is 1
signal input bias[nFilters];
signal input remainder[outRows][outCols][nFilters];
signal input out[outRows][outCols][nFilters];
component mul[outRows][outCols][nFilters];
component elemSum[outRows][outCols][nFilters];
var valid_groups = nFilters % nChannels;
var filtersPerChannel = nFilters / nChannels;
signal groups;
groups <== valid_groups;
component is_zero = IsZero();
is_zero.in <== groups;
is_zero.out === 1;
for (var row=0; row<outRows; row++) {
for (var col=0; col<outCols; col++) {
for (var filterMultiplier=1; filterMultiplier<=filtersPerChannel; filterMultiplier++) {
for (var channel=0; channel<nChannels; channel++) {
var filter = filterMultiplier*channel;
mul[row][col][filter] = matElemMul(kernelSize,kernelSize);
for (var x=0; x<kernelSize; x++) {
for (var y=0; y<kernelSize; y++) {
mul[row][col][filter].a[x][y] <== in[row*strides+x][col*strides+y][channel];
mul[row][col][filter].b[x][y] <== weights[x][y][filter];
}
}
elemSum[row][col][filter] = matElemSum(kernelSize,kernelSize);
for (var x=0; x<kernelSize; x++) {
for (var y=0; y<kernelSize; y++) {
elemSum[row][col][filter].a[x][y] <== mul[row][col][filter].out[x][y];
}
}
out[row][col][filter] * n + remainder[row][col][filter] === elemSum[row][col][filter].out + bias[filter];
}
}
}
}
}

39
circuits/pointwiseConv2D.circom Normal file
View File

@@ -0,0 +1,39 @@
pragma circom 2.1.1;
// include "./Conv2D.circom";
include "./circomlib/sign.circom";
include "./circomlib/bitify.circom";
include "./circomlib/comparators.circom";
include "./circomlib-matrix/matElemMul.circom";
include "./circomlib-matrix/matElemSum.circom";
include "./util.circom";
// Pointwise Convolution layer
// Note that nFilters must be a multiple of nChannels
template PointwiseConv2D (nRows, nCols, nChannels, nFilters, n) {
var outRows = nRows; // kernel size and strides are 1
var outCols = nCols;
signal input in[nRows][nCols][nChannels];
signal input weights[nChannels][nFilters]; // weights are 2d because kernel_size is 1
signal input bias[nFilters];
signal input out[outRows][outCols][nFilters];
signal input remainder[outRows][outCols][nFilters];
component sum[outRows][outCols][nFilters];
for (var row=0; row<outRows; row++) {
for (var col=0; col<outCols; col++) {
for (var filter=0; filter<nFilters; filter++) {
sum[row][col][filter] = Sum(nChannels);
for (var channel=0; channel<nChannels; channel++) {
sum[row][col][filter].in[channel] <== in[row][col][channel] * weights[channel][filter];
}
out[row][col][filter] * n + remainder[row][col][filter] === sum[row][col][filter].out + bias[filter];
}
}
}
}
// component main = PointwiseConv2D(32, 32, 8, 16);

67
circuits/separableConv2D.circom Normal file
View File

@@ -0,0 +1,67 @@
pragma circom 2.1.1;
include "./PointwiseConv2D.circom";
include "./DepthwiseConv2D.circom";
// Separable convolution layer with valid padding.
// Quantization is done by the caller by multiplying float values by 10**exp.
template SeparableConv2D (nRows, nCols, nChannels, nDepthFilters, nPointFilters, depthKernelSize, strides, n) {
var outRows = (nRows-depthKernelSize)\strides+1;
var outCols = (nCols-depthKernelSize)\strides+1;
signal input in[nRows][nCols][nChannels];
signal input depthWeights[depthKernelSize][depthKernelSize][nDepthFilters]; // weights are 3d because depth is 1
signal input depthBias[nDepthFilters];
signal input depthRemainder[outRows][outCols][nDepthFilters];
signal input depthOut[outRows][outCols][nDepthFilters];
signal input pointWeights[nChannels][nPointFilters]; // weights are 2d because depthKernelSize is one
signal input pointBias[nPointFilters];
signal input pointRemainder[outRows][outCols][nPointFilters];
signal input pointOut[outRows][outCols][nPointFilters];
component depthConv = DepthwiseConv2D(nRows, nCols, nChannels, nDepthFilters, depthKernelSize, strides, n);
component pointConv = PointwiseConv2D(outRows, outCols, nDepthFilters, nPointFilters, n);
for (var filter=0; filter<nDepthFilters; filter++) {
for (var x=0; x<depthKernelSize; x++) {
for (var y=0; y<depthKernelSize; y++) {
depthConv.weights[x][y][filter] <== depthWeights[x][y][filter];
}
}
depthConv.bias[filter] <== depthBias[filter];
}
for (var row=0; row < nRows; row++) {
for (var col=0; col < nCols; col++) {
for (var channel=0; channel < nChannels; channel++) {
depthConv.in[row][col][channel] <== in[row][col][channel];
}
}
}
for (var row=0; row < outRows; row++) {
for (var col=0; col < outCols; col++) {
for (var filter=0; filter < nDepthFilters; filter++) {
depthConv.remainder[row][col][filter] <== depthRemainder[row][col][filter];
depthConv.out[row][col][filter] <== depthOut[row][col][filter];
pointConv.in[row][col][filter] <== depthOut[row][col][filter];
}
}
}
for (var filter=0; filter < nPointFilters; filter++) {
for (var channel=0; channel < nChannels; channel++) {
pointConv.weights[channel][filter] <== pointWeights[channel][filter];
}
pointConv.bias[filter] <== pointBias[filter];
}
for (var row=0; row < outRows; row++) {
for (var col=0; col < outCols; col++) {
for (var filter=0; filter < nPointFilters; filter++) {
pointConv.remainder[row][col][filter] <== pointRemainder[row][col][filter];
pointConv.out[row][col][filter] <== pointOut[row][col][filter];
}
}
}
}

193
models/depthwiseConv2D.ipynb Normal file
View File

@@ -0,0 +1,193 @@
{
"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 // 2\n",
"MAX_NEGATIVE = MAX_POSITIVE + 1 # The most positive number\n",
"\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)//strides + 1\n",
" outCols = (nCols - kernelSize)//strides + 1\n",
" \n",
" # out = np.zeros((outRows, outCols, nFilters))\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",
" # remainder = np.zeros((outRows, outCols, nFilters))\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(out[row][col][channel] % n))\n",
" out[row][col][channel] = int(out[row][col][channel] // n)\n",
" \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).tolist()\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
}

1
models/depthwiseConv2D_input.json Normal file
View File

File diff suppressed because one or more lines are too long

170
models/pointwiseConv2D.ipynb Normal file
View File

@@ -0,0 +1,170 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "2b70084b-44da-4142-9e24-c9c8231828db",
"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": "e7533193-266d-4a59-b9aa-54179d40aa41",
"metadata": {},
"outputs": [],
"source": [
"p = 21888242871839275222246405745257275088548364400416034343698204186575808495617\n",
"EXPONENT = 15\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": "4dec98ed-cd14-442b-93b5-8f3660726773",
"metadata": {},
"outputs": [],
"source": [
"input = torch.randn((1, 3, 5, 5))\n",
"model = SeparableConv2D(3, 6)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "92b62f7c-5ac1-4c69-9add-9a859d66c327",
"metadata": {},
"outputs": [],
"source": [
"def PointwiseConv2d(nRows, nCols, nChannels, nFilters, strides, n, input, weights, bias):\n",
" kernelSize = 1\n",
" outRows = (nRows - kernelSize)//strides + 1\n",
" outCols = (nCols - kernelSize)//strides + 1\n",
" out = [[[0 for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
" str_out = [[[0 for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
" remainder = [[[None for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
" for row in range(outRows):\n",
" for col in range(outCols):\n",
" for filter in range(nFilters):\n",
" for k in range(nChannels):\n",
" out[row][col][filter] += int(input[row*strides, col*strides, k]) * int(weights[k, filter])\n",
" \n",
" out[row][col][filter] += int(bias[filter])\n",
" remainder[row][col][filter] = str(int(out[row][col][filter] % n))\n",
" out[row][col][filter] = int(out[row][col][filter] // n)\n",
" str_out[row][col][filter] = str(out[row][col][filter] % p)\n",
" \n",
" return out, str_out, remainder"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "0c664ba3-b722-482b-84f4-f83bab1d1bdb",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"quantized_image.shape=(5, 5, 3)\n",
"quantized_weights.shape=(3, 6)\n",
"expected.shape=(1, 6, 5, 5)\n",
"expected.shape=(5, 5, 6)\n"
]
}
],
"source": [
"weights = model.pw_conv.weight.detach().numpy()\n",
"bias = torch.zeros(weights.shape[0]).numpy()\n",
"\n",
"expected = model.pw_conv(input).detach().numpy()\n",
"\n",
"weights = weights.transpose((2, 3, 1, 0)).squeeze()\n",
"\n",
"quantized_image = input.squeeze().numpy().transpose((1, 2, 0)) * 10**EXPONENT\n",
"quantized_weights = weights * 10**EXPONENT\n",
"print(f\"{quantized_image.shape=}\")\n",
"print(f\"{quantized_weights.shape=}\")\n",
"\n",
"actual, str_actual, remainder = PointwiseConv2d(5, 5, 3, 6, 1, 10**EXPONENT, quantized_image.round(), quantized_weights.round(), bias)\n",
"\n",
"actual_scaled = [[[actual[i][j][k] / 10**EXPONENT for k in range(6)] for j in range(5)] for i in range(5)]\n",
"\n",
"expected = expected.squeeze().transpose((1, 2, 0))\n",
"\n",
"assert(np.allclose(expected, actual_scaled, atol=0.00001))"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "8b595d39-ca92-4c45-b04e-e7eb85b4c843",
"metadata": {},
"outputs": [],
"source": [
"circuit_in = quantized_image.round().astype(int).astype(str).tolist()\n",
"circuit_weights = quantized_weights.round().astype(int).astype(str).tolist()\n",
"circuit_bias = bias.round().astype(int).astype(str).tolist()\n",
"\n",
"input_json_path = \"pointwiseConv2D_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\": str_actual,\n",
" \"bias\": circuit_bias,\n",
" },\n",
" input_file)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cd6f84d3-4d70-421c-9067-5ed314c967a8",
"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
}

1
models/pointwiseConv2D_input.json Normal file
View File

File diff suppressed because one or more lines are too long

499
models/separableConv2D.ipynb Normal file
View File

@@ -0,0 +1,499 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "aa5be75a-ee5f-45b0-891b-da2dd340dd00",
"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": "f85ed78d-97ef-4979-acac-8d95b34a84ae",
"metadata": {},
"outputs": [],
"source": [
"p = 21888242871839275222246405745257275088548364400416034343698204186575808495617\n",
"CIRCOM_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617\n",
"MAX_POSITIVE = CIRCOM_PRIME // 2\n",
"MAX_NEGATIVE = MAX_POSITIVE + 1 # The most positive number\n",
"CIRCOM_NEGATIVE_1 = 21888242871839275222246405745257275088548364400416034343698204186575808495617 - 1\n",
"EXPONENT = 15\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\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"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "32e117a1-32aa-4b4b-91d0-4b4b78071b6b",
"metadata": {},
"outputs": [],
"source": [
"# def DepthwiseConv(nRows, nCols, nChannels, nFilters, kernelSize, strides, n, input, weights, bias):\n",
"# assert(nFilters % nChannels == 0)\n",
"# outRows = (nRows - kernelSize)//strides + 1\n",
"# outCols = (nCols - kernelSize)//strides + 1\n",
" \n",
"# out = np.zeros((outRows, outCols, nFilters))\n",
"# remainder = np.zeros((outRows, outCols, nFilters))\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] += input[row*strides+x, col*strides+y, channel] * weights[x, y, channel]\n",
" \n",
"# out[row][col][channel] += bias[channel]\n",
"# remainder[row][col][channel] = out[row][col][channel] % n\n",
"# out[row][col][channel] = out[row][col][channel] / n\n",
" \n",
"# return out, remainder\n",
" \n",
"# def PointwiseConv2d(nRows, nCols, nChannels, nFilters, strides, n, input, weights, bias):\n",
"# kernelSize = 1\n",
"# outRows = (nRows - kernelSize)//strides + 1\n",
"# outCols = (nCols - kernelSize)//strides + 1\n",
"# out = np.zeros((outRows, outCols, nFilters))\n",
"# for row in range(outRows):\n",
"# for col in range(outCols):\n",
"# for filter in range(nFilters):\n",
"# for k in range(nChannels):\n",
"# out[row, col, filter] += input[row*strides, col*strides, k] * weights[k, filter]\n",
" \n",
"# out[row][col][filter] += bias[filter]\n",
"# out[row][col][filter] = out[row][col][filter] / n\n",
" \n",
"# return out\n",
"\n",
"# def SeparableConvImpl(nRows, nCols, nChannels, nDepthFilters, nPointFilters, kernelSize, strides, n, input, depthWeights, pointWeights, depthBias, pointBias):\n",
"# outRows = (nRows - kernelSize)//strides + 1\n",
"# outCols = (nCols - kernelSize)//strides + 1\n",
"\n",
"# depthOut, rem = DepthwiseConv(nRows, nCols, nChannels, nDepthFilters, kernelSize, strides, n, input, depthWeights, depthBias)\n",
"# pointOut = PointwiseConv2d(outRows, outCols, nChannels, nPointFilters, strides, n, depthOut, pointWeights, pointBias)\n",
"# return pointOut"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "e3dfadfd-2587-4708-9dd5-535a999ed359",
"metadata": {},
"outputs": [],
"source": [
"# def DepthwiseConvInt(nRows, nCols, nChannels, nFilters, kernelSize, strides, n, input, weights, bias):\n",
"# assert(nFilters % nChannels == 0)\n",
"# outRows = (nRows - kernelSize)//strides + 1\n",
"# outCols = (nCols - kernelSize)//strides + 1\n",
" \n",
"# Input = [[[str(input[i][j][k] % p) for k in range(nChannels)] for j in range(nCols)] for i in range(nRows)]\n",
"# Weights = [[[str(weights[i][j][k] % p) for k in range(nChannels)] for j in range(kernelSize)] for i in range(kernelSize)]\n",
"# Bias = [str(bias[i] % p) for i in range(nFilters)]\n",
"# out = [[[0 for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
"# str_out = [[[0 for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
"# remainder = [[[None 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(out[row][col][channel] % n))\n",
"# out[row][col][channel] = int((out[row][col][channel] // n))\n",
"# str_out[row][col][channel] = str(out[row][col][channel] % p)\n",
" \n",
"# return Input, Weights, Bias, out, str_out, remainder\n",
" \n",
"# def PointwiseConv2dInt(nRows, nCols, nChannels, nFilters, strides, n, input, weights, bias):\n",
"# kernelSize = 1\n",
"# outRows = (nRows - kernelSize)//strides + 1\n",
"# outCols = (nCols - kernelSize)//strides + 1\n",
" \n",
"# Input = [[[str(input[i][j][k] % p) for k in range(nChannels)] for j in range(nCols)] for i in range(nRows)]\n",
"# Weights = [[str(weights[k][l] % p) for l in range(nFilters)] for k in range(nChannels)]\n",
"# Bias = [str(bias[i] % p) for i in range(nFilters)]\n",
"# out = [[[0 for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
"# str_out = [[[0 for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
"# remainder = [[[None 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 filter in range(nFilters):\n",
"# for channel in range(nChannels):\n",
"# out[row][col][filter] += int(input[row*strides][col*strides][channel]) * int(weights[channel][filter])\n",
" \n",
"# out[row][col][filter] += int(bias[filter])\n",
"# remainder[row][col][filter] = str(int(out[row][col][filter] % n))\n",
"# out[row][col][filter] = str(out[row][col][filter] // n % p)\n",
"# return Input, Weights, Bias, out, remainder\n",
"\n",
"# def SeparableConvInt(nRows, nCols, nChannels, nDepthFilters, nPointFilters, kernelSize, strides, n, input, depthWeights, pointWeights, depthBias, pointBias):\n",
"# outRows = (nRows - kernelSize)//strides + 1\n",
"# outCols = (nCols - kernelSize)//strides + 1\n",
"\n",
"# Input, DepthWeights, DepthBias, depthOut, depthStrOut, depthRemainder = DepthwiseConvInt(nRows, nCols, nChannels, nDepthFilters, kernelSize, strides, n, input, depthWeights, depthBias)\n",
"# test = [[[from_circom(int(depthStrOut[i][j][k])) for k in range(3)] for j in range(5)] for i in range(5)]\n",
"# assert(test == depthOut)\n",
"# pInput, PointWeights, PointBias, pointOut, pointRem = PointwiseConv2dInt(outRows, outCols, nChannels, nPointFilters, strides, n, depthOut, pointWeights, pointBias)\n",
" \n",
"# return Input, DepthWeights, DepthBias, depthOut, depthStrOut, depthRemainder, PointWeights, PointBias, pointOut, pointRem"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "cc1a4a27-a1dc-4565-90e3-12e6d7122157",
"metadata": {},
"outputs": [],
"source": [
"def DepthwiseConv(nRows, nCols, nChannels, nFilters, kernelSize, strides, n, input, weights, bias):\n",
" assert(nFilters % nChannels == 0)\n",
" outRows = (nRows - kernelSize)//strides + 1\n",
" outCols = (nCols - kernelSize)//strides + 1\n",
" \n",
" # out = np.zeros((outRows, outCols, nFilters))\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",
" # remainder = np.zeros((outRows, outCols, nFilters))\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(out[row][col][channel] % n))\n",
" out[row][col][channel] = int(out[row][col][channel] // n)\n",
" \n",
" return out, remainder\n",
" \n",
"def PointwiseConv2d(nRows, nCols, nChannels, nFilters, strides, n, input, weights, bias):\n",
" kernelSize = 1\n",
" outRows = (nRows - kernelSize)//strides + 1\n",
" outCols = (nCols - kernelSize)//strides + 1\n",
" out = [[[0 for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
" str_out = [[[0 for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
" remainder = [[[None for _ in range(nFilters)] for _ in range(outCols)] for _ in range(outRows)]\n",
" for row in range(outRows):\n",
" for col in range(outCols):\n",
" for filter in range(nFilters):\n",
" for k in range(nChannels):\n",
" out[row][col][filter] += int(input[row*strides][col*strides][k]) * int(weights[k, filter])\n",
" \n",
" out[row][col][filter] += int(bias[filter])\n",
" remainder[row][col][filter] = str(int(out[row][col][filter] % n))\n",
" out[row][col][filter] = int(out[row][col][filter] // n)\n",
" str_out[row][col][filter] = str(out[row][col][filter] % p)\n",
" \n",
" return out, str_out, remainder\n",
" \n",
"def SeparableConvImpl(nRows, nCols, nChannels, nDepthFilters, nPointFilters, kernelSize, strides, n, input, depthWeights, pointWeights, depthBias, pointBias):\n",
" outRows = (nRows - kernelSize)//strides + 1\n",
" outCols = (nCols - kernelSize)//strides + 1\n",
"\n",
" depth_out, depth_remainder = DepthwiseConv(nRows, nCols, nChannels, nDepthFilters, kernelSize, strides, n, input, depthWeights, depthBias)\n",
" point_out, point_str_out, point_remainder = PointwiseConv2d(outRows, outCols, nChannels, nPointFilters, strides, n, depth_out, pointWeights, pointBias)\n",
" return depth_out, depth_remainder, point_out, point_str_out, point_remainder"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "cfa6df6a-9a0c-4150-9df0-30e2700d4f6b",
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'torch' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[0;32mIn[2], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241m.\u001b[39mrandn((\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m5\u001b[39m, \u001b[38;5;241m5\u001b[39m))\n\u001b[1;32m 2\u001b[0m model \u001b[38;5;241m=\u001b[39m SeparableConv2D(\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m6\u001b[39m)\n",
"\u001b[0;31mNameError\u001b[0m: name 'torch' is not defined"
]
}
],
"source": [
"input = torch.randn((1, 3, 5, 5))\n",
"model = SeparableConv2D(3, 6)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "5db59f3a-e610-473a-8dfc-1d5e812748f4",
"metadata": {},
"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) # Padding for convolution with \"same\" configuration\n",
"# padded = padded.squeeze().numpy().transpose((1, 2, 0))\n",
"# weights = weights.transpose((1, 2, 0))\n",
"\n",
"# actual, rem = DepthwiseConv(7, 7, 3, 3, 3, 1, 1, padded, weights, bias)\n",
"# expected = expected.squeeze().transpose((1, 2, 0))\n",
"\n",
"# assert(np.allclose(expected, actual, atol=0.00001))"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "47ce42c7-b417-46ba-a31b-1ae23234a2cd",
"metadata": {},
"outputs": [],
"source": [
"# weights = model.pw_conv.weight.detach().numpy()\n",
"# print(f\"{weights.shape=}\")\n",
"# bias = torch.zeros(weights.shape[0]).numpy()\n",
"\n",
"# expected = model.pw_conv(input).detach().numpy()\n",
"\n",
"# padded = input.squeeze().numpy().transpose((1, 2, 0))\n",
"# print(padded.shape)\n",
"# weights = weights.transpose((2, 3, 1, 0)).squeeze()\n",
"\n",
"# actual = PointwiseConv2d(5, 5, 3, 6, 1, 1, padded, weights, bias)\n",
"\n",
"# expected = expected.squeeze().transpose((1, 2, 0))\n",
"\n",
"# assert(np.allclose(expected, actual, atol=0.00001))"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "7a36a0a1-6965-4184-93a5-5d121d6d1856",
"metadata": {},
"outputs": [],
"source": [
"# depthWeights = model.dw_conv.weight.squeeze().detach().numpy()\n",
"# depthBias = torch.zeros(depthWeights.shape[0]).numpy()\n",
"\n",
"# depthWeights = depthWeights.transpose((1, 2, 0))\n",
"\n",
"# pointWeights = model.pw_conv.weight.detach().numpy()\n",
"# print(f\"{depthWeights.shape=}\")\n",
"# pointBias = torch.zeros(pointWeights.shape[0]).numpy()\n",
"# pointWeights = pointWeights.transpose((2, 3, 1, 0)).squeeze()\n",
"\n",
"# expected = model(input).detach().numpy()\n",
"# print(f\"{expected.shape=}\")\n",
"\n",
"# padded = F.pad(input, (1,1,1,1), \"constant\", 0) # Padding for convolution with \"same\" configuration\n",
"# padded = padded.squeeze().numpy().transpose((1, 2, 0))\n",
"\n",
"# print(pointBias.shape)\n",
"# actual = SeparableConvImpl(7, 7, 3, 3, 6, 3, 1, 1, padded, depthWeights, pointWeights, depthBias, pointBias)\n",
"# expected = expected.squeeze().transpose((1, 2, 0))\n",
"\n",
"# assert(np.allclose(expected, actual, atol=0.00001))"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "fd587b58-1646-4ec8-9a79-4f891dab0276",
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"depthWeights.shape=(3, 3, 3)\n",
"expected.shape=(1, 6, 5, 5)\n",
"(6,)\n"
]
},
{
"ename": "NameError",
"evalue": "name 'depthOut' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[0;32mIn[10], line 23\u001b[0m\n\u001b[1;32m 20\u001b[0m quantized_depth_weights \u001b[38;5;241m=\u001b[39m depthWeights \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m10\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mEXPONENT\n\u001b[1;32m 21\u001b[0m quantized_point_weights \u001b[38;5;241m=\u001b[39m pointWeights \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m10\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mEXPONENT\n\u001b[0;32m---> 23\u001b[0m depth_out, depth_remainder, point_out, point_str_out, point_remainder \u001b[38;5;241m=\u001b[39m \u001b[43mSeparableConvImpl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m7\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m7\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m6\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mEXPONENT\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mquantized_image\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mround\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mastype\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mquantized_depth_weights\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mround\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mastype\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mquantized_point_weights\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mround\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mastype\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdepthBias\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mastype\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpointBias\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mastype\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 25\u001b[0m actual_scaled \u001b[38;5;241m=\u001b[39m [[[point_out[i][j][k] \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m10\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mEXPONENT \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m6\u001b[39m)] \u001b[38;5;28;01mfor\u001b[39;00m j \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m5\u001b[39m)] \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m5\u001b[39m)]\n\u001b[1;32m 27\u001b[0m expected \u001b[38;5;241m=\u001b[39m expected\u001b[38;5;241m.\u001b[39msqueeze()\u001b[38;5;241m.\u001b[39mtranspose((\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m0\u001b[39m))\n",
"Cell \u001b[0;32mIn[5], line 60\u001b[0m, in \u001b[0;36mSeparableConvImpl\u001b[0;34m(nRows, nCols, nChannels, nDepthFilters, nPointFilters, kernelSize, strides, n, input, depthWeights, pointWeights, depthBias, pointBias)\u001b[0m\n\u001b[1;32m 57\u001b[0m outCols \u001b[38;5;241m=\u001b[39m (nCols \u001b[38;5;241m-\u001b[39m kernelSize)\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39mstrides \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 59\u001b[0m depth_out, depth_remainder \u001b[38;5;241m=\u001b[39m DepthwiseConv(nRows, nCols, nChannels, nDepthFilters, kernelSize, strides, n, \u001b[38;5;28minput\u001b[39m, depthWeights, depthBias)\n\u001b[0;32m---> 60\u001b[0m point_out, point_str_out, point_remainder \u001b[38;5;241m=\u001b[39m PointwiseConv2d(outRows, outCols, nChannels, nPointFilters, strides, n, \u001b[43mdepthOut\u001b[49m, pointWeights, pointBias)\n\u001b[1;32m 61\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m depth_out, depth_remainder, point_out, point_str_out, point_remainder\n",
"\u001b[0;31mNameError\u001b[0m: name 'depthOut' is not defined"
]
}
],
"source": [
"depthWeights = model.dw_conv.weight.squeeze().detach().numpy()\n",
"depthBias = torch.zeros(depthWeights.shape[0]).numpy()\n",
"\n",
"depthWeights = depthWeights.transpose((1, 2, 0))\n",
"\n",
"pointWeights = model.pw_conv.weight.detach().numpy()\n",
"print(f\"{depthWeights.shape=}\")\n",
"pointBias = torch.zeros(pointWeights.shape[0]).numpy()\n",
"pointWeights = pointWeights.transpose((2, 3, 1, 0)).squeeze()\n",
"\n",
"expected = model(input).detach().numpy()\n",
"print(f\"{expected.shape=}\")\n",
"\n",
"padded = F.pad(input, (1,1,1,1), \"constant\", 0) # Padding for convolution with \"same\" configuration\n",
"padded = padded.squeeze().numpy().transpose((1, 2, 0))\n",
"\n",
"print(pointBias.shape)\n",
"# actual = SeparableConvImpl(7, 7, 3, 3, 6, 3, 1, 1, padded, depthWeights, pointWeights, depthBias, pointBias)\n",
"quantized_image = padded * 10**EXPONENT\n",
"quantized_depth_weights = depthWeights * 10**EXPONENT\n",
"quantized_point_weights = pointWeights * 10**EXPONENT\n",
"\n",
"depth_out, depth_remainder, point_out, point_str_out, point_remainder = SeparableConvImpl(7, 7, 3, 3, 6, 3, 1, 10**EXPONENT, quantized_image.round().astype(int), quantized_depth_weights.round().astype(int), quantized_point_weights.round().astype(int), depthBias.astype(int), pointBias.astype(int))\n",
"\n",
"actual_scaled = [[[point_out[i][j][k] / 10**EXPONENT for k in range(6)] for j in range(5)] for i in range(5)]\n",
"\n",
"expected = expected.squeeze().transpose((1, 2, 0))\n",
"\n",
"assert(np.allclose(expected, actual_scaled, atol=0.00001))\n",
"\n",
"\n",
"# Input, DepthWeights, DepthBias, depthOut, depthStrOut, DepthRem, PointWeights, PointBias, pointOut, pointRem = SeparableConvInt(7, 7, 3, 3, 6, 3, 1, 10**EXPONENT, quantized_image.round().astype(int), quantized_depth_weights.round().astype(int), quantized_point_weights.round().astype(int), depthBias.astype(int), pointBias.astype(int))\n",
"\n",
"circuit_in = quantized_image.round().astype(int).astype(str).tolist()\n",
"circuit_depth_weights = quantized_depth_weights.round().astype(int).astype(str).tolist()\n",
"circuit_point_weights = quantized_point_weights.round().astype(int).astype(str).tolist()\n",
"circuit_depth_bias = depthBias.round().astype(int).astype(str).tolist()\n",
"circuit_point_bias = pointBias.round().astype(int).astype(str).tolist()\n",
"\n",
"\n",
"input_json_path = \"separableConv2D_input.json\"\n",
"with open(input_json_path, \"w\") as input_file:\n",
" json.dump({\"in\": circuit_in,\n",
" \"depthWeights\": circuit_depth_weights,\n",
" \"depthBias\": circuit_depth_bias,\n",
" \"depthRemainder\": depth_remainder,\n",
" \"depthOut\": depth_out,\n",
" \n",
" \"pointWeights\": circuit_point_weights,\n",
" \"pointBias\": circuit_point_bias,\n",
" \"pointRemainder\": point_remainder,\n",
" \"pointOut\": point_str_out,\n",
" },\n",
" input_file)\n"
]
},
{
"cell_type": "code",
"execution_count": 44,
"id": "f0dcbca8-7f2f-47ea-b662-29a8560774b1",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 289246014266912, 458852178050435, -104551710192411,\n",
" -85286796832706, 70991076566637, -373719950995314])"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"test = np.array(actual)\n",
"test[0][0]"
]
},
{
"cell_type": "code",
"execution_count": 45,
"id": "3a652322-2fa0-4f51-bb2f-ed49bd94c65a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 0.289246 , 0.45885214, -0.10455171, -0.0852868 , 0.07099106,\n",
" -0.37371993], dtype=float32)"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"expected[0][0]"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "56d3dda8-af64-402e-9c86-b333ca6782ba",
"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
}

1
models/separableConv2D_input.json Normal file
View File

File diff suppressed because one or more lines are too long

4
test/BatchNormalization.js
View File

@@ -16,10 +16,10 @@ describe("BatchNormalization layer test", function () {
it("(5,5,3) -> (5,5,3)", async () => {
const INPUT = require("../models/batchNormalization_input.json");
const circuit = await wasm_tester(path.join(__dirname, "circuits", "batchNormalization_test.circom"));
const circuit = await wasm_tester(path.join(__dirname, "circuits", "BatchNormalization_test.circom"));
const witness = await circuit.calculateWitness(INPUT, true);
assert(Fr.eq(Fr.e(witness[0]),Fr.e(1)));
});
});
});

25
test/DepthwiseConv2D.js Normal file
View File

@@ -0,0 +1,25 @@
const chai = require("chai");
const path = require("path");
const wasm_tester = require("circom_tester").wasm;
const F1Field = require("ffjavascript").F1Field;
const Scalar = require("ffjavascript").Scalar;
exports.p = Scalar.fromString("21888242871839275222246405745257275088548364400416034343698204186575808495617");
const Fr = new F1Field(exports.p);
const assert = chai.assert;
describe("DepthwiseConv2D layer test", function () {
this.timeout(100000000);
it("(7,7,3) -> (5,5,3)", async () => {
const INPUT = require("../models/depthwiseConv2D_input.json");
const circuit = await wasm_tester(path.join(__dirname, "circuits", "DepthwiseConv2D_test.circom"));
const witness = await circuit.calculateWitness(INPUT, true);
assert(Fr.eq(Fr.e(witness[0]),Fr.e(1)));
});
});

4
test/Flatten2D.js
View File

@@ -16,10 +16,10 @@ describe("Flatten2D layer test", function () {
it("(5,5,3) -> 75", async () => {
const INPUT = require("../models/flatten2D_input.json");
const circuit = await wasm_tester(path.join(__dirname, "circuits", "flatten2D_test.circom"));
const circuit = await wasm_tester(path.join(__dirname, "circuits", "Flatten2D_test.circom"));
const witness = await circuit.calculateWitness(INPUT, true);
assert(Fr.eq(Fr.e(witness[0]),Fr.e(1)));
});
});
});

25
test/PointwiseConv2D.js Normal file
View File

@@ -0,0 +1,25 @@
const chai = require("chai");
const path = require("path");
const wasm_tester = require("circom_tester").wasm;
const F1Field = require("ffjavascript").F1Field;
const Scalar = require("ffjavascript").Scalar;
exports.p = Scalar.fromString("21888242871839275222246405745257275088548364400416034343698204186575808495617");
const Fr = new F1Field(exports.p);
const assert = chai.assert;
describe("PointwiseConv2D layer test", function () {
this.timeout(100000000);
it("(7,7,3) -> (5,5,3)", async () => {
const INPUT = require("../models/pointwiseConv2D_input.json");
const circuit = await wasm_tester(path.join(__dirname, "circuits", "PointwiseConv2D_test.circom"));
const witness = await circuit.calculateWitness(INPUT, true);
assert(Fr.eq(Fr.e(witness[0]),Fr.e(1)));
});
});

25
test/SeparableConv2D.js Normal file
View File

@@ -0,0 +1,25 @@
const chai = require("chai");
const path = require("path");
const wasm_tester = require("circom_tester").wasm;
const F1Field = require("ffjavascript").F1Field;
const Scalar = require("ffjavascript").Scalar;
exports.p = Scalar.fromString("21888242871839275222246405745257275088548364400416034343698204186575808495617");
const Fr = new F1Field(exports.p);
const assert = chai.assert;
describe("SeparableConv2D layer test", function () {
this.timeout(100000000);
it("(7,7,3) -> (5,5,3)", async () => {
const INPUT = require("../models/separableConv2D_input.json");
const circuit = await wasm_tester(path.join(__dirname, "circuits", "SeparableConv2D_test.circom"));
const witness = await circuit.calculateWitness(INPUT, true);
assert(Fr.eq(Fr.e(witness[0]),Fr.e(1)));
});
});

5
test/circuits/DepthwiseConv2D_test.circom Normal file
View File

@@ -0,0 +1,5 @@
pragma circom 2.0.0;
include "../../circuits/DepthwiseConv2D.circom";
component main = DepthwiseConv2D(7, 7, 3, 3, 3, 1, 10**15);

5
test/circuits/PointwiseConv2D_test.circom Normal file
View File

@@ -0,0 +1,5 @@
pragma circom 2.0.0;
include "../../circuits/PointwiseConv2D.circom";
component main = PointwiseConv2D(5, 5, 3, 6, 10**15);

5
test/circuits/SeparableConv2D_test.circom Normal file
View File

@@ -0,0 +1,5 @@
pragma circom 2.0.0;
include "../../circuits/SeparableConv2D.circom";
component main = SeparableConv2D(7, 7, 3, 3, 6, 3, 1, 10**15);

4
test/encryption.js
View File

@@ -205,7 +205,7 @@ describe("crypto circuits test", function () {
});
// TODO: encrypt a model
it("encrypt entire model in circom, decrypt in js", async () => {
it.skip("encrypt entire model in circom, decrypt in js", async () => {
const circuit = await wasm_tester(path.join(__dirname, "circuits", "encrypted_mnist_latest_test.circom"));
const json = require("../models/mnist_latest_input.json");
@@ -263,4 +263,4 @@ describe("crypto circuits test", function () {
}
});
});
});