sinabs 2.0.1.dev2__tar.gz → 2.0.1.dev3__tar.gz

{sinabs-2.0.1.dev2 → sinabs-2.0.1.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sinabs
-Version: 2.0.1.dev2
+Version: 2.0.1.dev3
 Summary: SynSense Spiking Neural Network simulator for deep neural networks (DNNs).
 Home-page: UNKNOWN
 Author: SynSense (formerly AiCTX)

{sinabs-2.0.1.dev2 → sinabs-2.0.1.dev3}/sinabs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sinabs
-Version: 2.0.1.dev2
+Version: 2.0.1.dev3
 Summary: SynSense Spiking Neural Network simulator for deep neural networks (DNNs).
 Home-page: UNKNOWN
 Author: SynSense (formerly AiCTX)

{sinabs-2.0.1.dev2 → sinabs-2.0.1.dev3}/sinabs.egg-info/SOURCES.txt

@@ -277,6 +277,8 @@ tests/test_layers/test_reshaping.py
 tests/test_layers/test_sig2spk.py
 tests/test_layers/test_stateful_layer.py
 tests/test_residual/NIR_graph_nonseq.ipynb
+tests/test_residual/test_jit_tracer_ann.ipynb
+tests/test_residual/test_jit_tracer_cnn.ipynb
 tests/test_specksim/test_specksim_bindings.py
 tests/test_specksim/test_specksim_conversion.py
 tests/test_specksim/test_specksim_network.py

sinabs-2.0.1.dev3/sinabs.egg-info/pbr.json

@@ -0,0 +1 @@
+{"git_version": "276eda3", "is_release": false}

sinabs-2.0.1.dev3/tests/test_residual/NIR_graph_nonseq.ipynb

@@ -0,0 +1,204 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from sinabs import to_nir\n",
+    "import networkx as nx\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class NonSeq(nn.Module):\n",
+    "    def __init__(self, *args, **kwargs) -> None:\n",
+    "        super().__init__(*args, **kwargs)\n",
+    "                                      # input tensor   /  output tensor\n",
+    "        self.fc1 = nn.Linear(100, 50) # Size([1, 100]) /  Size([1, 50])\n",
+    "        self.fc2 = nn.Linear(50, 50)  # Size([1, 50])  /  Size([1, 50])\n",
+    "        self.fc3 = nn.Linear(50, 50)  # Size([1, 50])  /  Size([1, 50])\n",
+    "        self.fc4 = nn.Linear(50, 30)  # Size([1, 50])  /  Size([1, 30])\n",
+    "        self.fc5 = nn.Linear(30, 2)   # Size([1, 30])  /  Size([1, 2])\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "\n",
+    "        out1 = self.fc1(x)\n",
+    "        out2 = self.fc2(out1)\n",
+    "        out3 = self.fc3(out2)\n",
+    "        out4 = self.fc4(out3 + out2)\n",
+    "        out5 = self.fc5(out4)\n",
+    "\n",
+    "        return out5\n",
+    "\n",
+    "ann = NonSeq()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "7\n"
+     ]
+    }
+   ],
+   "source": [
+    "ann_graph = [\n",
+    "    ('input', 'fc1'),\n",
+    "    ('fc1', 'fc2'),\n",
+    "    ('fc2', 'fc3'),\n",
+    "    ('fc2', 'fc4'),\n",
+    "    ('fc3', 'fc4'),\n",
+    "    ('fc4', 'fc5'),\n",
+    "    ('fc5', 'output'),\n",
+    "]\n",
+    "\n",
+    "print(len(ann_graph))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# g_ideal = nx.DiGraph(ann_graph)\n",
+    "# nx.draw(g_ideal, with_labels = True)\n",
+    "# plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=================================\n",
+      "> input_data: torch.Size([1, 100])\n",
+      "  creating Node: Tensor_0(1, 100) <inp>\n",
+      "  returning Node: fc1 <inp>\n",
+      "> output_data: torch.Size([1, 50])\n",
+      "  returning Node: fc1 <out>\n",
+      "  creating Node: Tensor_1(1, 50) <out>\n",
+      "\n",
+      "\n",
+      "> input_data: torch.Size([1, 50])\n",
+      "  returning Node: Tensor_1(1, 50) <inp>\n",
+      "  returning Node: fc2 <inp>\n",
+      "> output_data: torch.Size([1, 50])\n",
+      "  returning Node: fc2 <out>\n",
+      "  creating Node: Tensor_2(1, 50) <out>\n",
+      "\n",
+      "\n",
+      "> input_data: torch.Size([1, 50])\n",
+      "  returning Node: Tensor_2(1, 50) <inp>\n",
+      "  returning Node: fc3 <inp>\n",
+      "> output_data: torch.Size([1, 50])\n",
+      "  returning Node: fc3 <out>\n",
+      "  creating Node: Tensor_3(1, 50) <out>\n",
+      "\n",
+      "\n",
+      "> input_data: torch.Size([1, 50])\n",
+      "  creating Node: Tensor_4(1, 50) <inp>\n",
+      "  returning Node: fc4 <inp>\n",
+      "> output_data: torch.Size([1, 30])\n",
+      "  returning Node: fc4 <out>\n",
+      "  creating Node: Tensor_5(1, 30) <out>\n",
+      "\n",
+      "\n",
+      "> input_data: torch.Size([1, 30])\n",
+      "  returning Node: Tensor_5(1, 30) <inp>\n",
+      "  returning Node: fc5 <inp>\n",
+      "> output_data: torch.Size([1, 2])\n",
+      "  returning Node: fc5 <out>\n",
+      "  creating Node: Tensor_6(1, 2) <out>\n",
+      "\n",
+      "\n",
+      "> input_data: torch.Size([1, 100])\n",
+      "> output_data: torch.Size([1, 2])\n",
+      "\n",
+      "\n",
+      "++++++++++++++++++++++++++++++++\n",
+      "  returning Node: fc1 \n",
+      "  returning Node: fc2 \n",
+      "  returning Node: fc2 \n",
+      "  returning Node: fc3 \n",
+      "  returning Node: fc4 \n",
+      "  returning Node: fc5 \n",
+      "-------------extract_nir_graph_v2(extract_torch_graph()) (wrong)---------------\n",
+      ">>>>  fc1\n",
+      ">>>>  fc2\n",
+      ">>>>  fc3\n",
+      ">>>>  fc4\n",
+      ">>>>  fc5\n",
+      "```mermaid\n",
+      "graph TD;\n",
+      "fc1 --> fc2;\n",
+      "fc2 --> fc3;\n",
+      "fc3;\n",
+      "fc4 --> fc5;\n",
+      "fc5;\n",
+      "\n",
+      "```\n",
+      " <class 'nirtorch.graph.Graph'>\n",
+      "--------------------------------------------------------\n",
+      "0: 1\n",
+      "1: 6 [('input', 'fc1'), ('fc1', 'fc2'), ('fc2', 'fc3'), ('fc3', 'output'), ('fc4', 'fc5'), ('fc5', 'output')]\n",
+      "2: 6\n"
+     ]
+    }
+   ],
+   "source": [
+    "nir_graph = to_nir(ann, torch.randn(1, 100))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# g_nir = nx.DiGraph(nir_graph.edges)\n",
+    "# nx.draw(g_nir, with_labels = True)\n",
+    "# plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "speck-rescnn",
+   "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.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

sinabs-2.0.1.dev3/tests/test_residual/test_jit_tracer_ann.ipynb

@@ -0,0 +1,204 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class NonSeq(nn.Module):\n",
+    "    def __init__(self, *args, **kwargs) -> None:\n",
+    "        super().__init__(*args, **kwargs)\n",
+    "        self.fc1 = nn.Linear(100, 50)\n",
+    "        self.fc2 = nn.Linear(50, 50)\n",
+    "        self.fc3 = nn.Linear(50, 50)\n",
+    "        self.fc4 = nn.Linear(50, 30)\n",
+    "        self.fc5 = nn.Linear(30, 2)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        out1 = self.fc1(x)\n",
+    "        out2 = self.fc2(out1)\n",
+    "        out3 = self.fc3(out2)\n",
+    "        out4 = self.fc4(out3 + out2)\n",
+    "        out5 = self.fc5(out4)\n",
+    "        return out5\n",
+    "\n",
+    "model = NonSeq()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dummy_input = torch.randn(1, 100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trace = torch.jit.trace(model, dummy_input)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trace_output = trace(dummy_input)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "graph(%self.1 : __torch__.___torch_mangle_15.NonSeq,\n",
+      "      %x : Float(1, 100, strides=[100, 1], requires_grad=0, device=cpu)):\n",
+      "  %fc5 : __torch__.torch.nn.modules.linear.___torch_mangle_14.Linear = prim::GetAttr[name=\"fc5\"](%self.1)\n",
+      "  %fc4 : __torch__.torch.nn.modules.linear.___torch_mangle_13.Linear = prim::GetAttr[name=\"fc4\"](%self.1)\n",
+      "  %fc3 : __torch__.torch.nn.modules.linear.___torch_mangle_12.Linear = prim::GetAttr[name=\"fc3\"](%self.1)\n",
+      "  %fc2 : __torch__.torch.nn.modules.linear.___torch_mangle_11.Linear = prim::GetAttr[name=\"fc2\"](%self.1)\n",
+      "  %fc1 : __torch__.torch.nn.modules.linear.___torch_mangle_10.Linear = prim::GetAttr[name=\"fc1\"](%self.1)\n",
+      "  %61 : Tensor = prim::CallMethod[name=\"forward\"](%fc1, %x)\n",
+      "  %62 : Tensor = prim::CallMethod[name=\"forward\"](%fc2, %61)\n",
+      "  %63 : Tensor = prim::CallMethod[name=\"forward\"](%fc3, %62)\n",
+      "  %32 : int = prim::Constant[value=1]() # /tmp/ipykernel_16069/242438593.py:14:0\n",
+      "  %input.5 : Float(1, 50, strides=[50, 1], requires_grad=1, device=cpu) = aten::add(%63, %62, %32) # /tmp/ipykernel_16069/242438593.py:14:0\n",
+      "  %64 : Tensor = prim::CallMethod[name=\"forward\"](%fc4, %input.5)\n",
+      "  %65 : Tensor = prim::CallMethod[name=\"forward\"](%fc5, %64)\n",
+      "  return (%65)\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(trace.graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "def forward(self,\n",
+      "    x: Tensor) -> Tensor:\n",
+      "  fc5 = self.fc5\n",
+      "  fc4 = self.fc4\n",
+      "  fc3 = self.fc3\n",
+      "  fc2 = self.fc2\n",
+      "  fc1 = self.fc1\n",
+      "  _0 = (fc2).forward((fc1).forward(x, ), )\n",
+      "  input = torch.add((fc3).forward(_0, ), _0)\n",
+      "  _1 = (fc5).forward((fc4).forward(input, ), )\n",
+      "  return _1\n",
+      " <class 'str'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(trace.code, type(trace.code))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(%fc5 : __torch__.torch.nn.modules.linear.___torch_mangle_14.Linear = prim::GetAttr[name=\"fc5\"](%self.1)\n",
+      ", fc5 defined in (%fc5 : __torch__.torch.nn.modules.linear.___torch_mangle_14.Linear = prim::GetAttr[name=\"fc5\"](%self.1)\n",
+      "))\n",
+      "(%fc4 : __torch__.torch.nn.modules.linear.___torch_mangle_13.Linear = prim::GetAttr[name=\"fc4\"](%self.1)\n",
+      ", fc4 defined in (%fc4 : __torch__.torch.nn.modules.linear.___torch_mangle_13.Linear = prim::GetAttr[name=\"fc4\"](%self.1)\n",
+      "))\n",
+      "(%fc3 : __torch__.torch.nn.modules.linear.___torch_mangle_12.Linear = prim::GetAttr[name=\"fc3\"](%self.1)\n",
+      ", fc3 defined in (%fc3 : __torch__.torch.nn.modules.linear.___torch_mangle_12.Linear = prim::GetAttr[name=\"fc3\"](%self.1)\n",
+      "))\n",
+      "(%fc2 : __torch__.torch.nn.modules.linear.___torch_mangle_11.Linear = prim::GetAttr[name=\"fc2\"](%self.1)\n",
+      ", fc2 defined in (%fc2 : __torch__.torch.nn.modules.linear.___torch_mangle_11.Linear = prim::GetAttr[name=\"fc2\"](%self.1)\n",
+      "))\n",
+      "(%fc1 : __torch__.torch.nn.modules.linear.___torch_mangle_10.Linear = prim::GetAttr[name=\"fc1\"](%self.1)\n",
+      ", fc1 defined in (%fc1 : __torch__.torch.nn.modules.linear.___torch_mangle_10.Linear = prim::GetAttr[name=\"fc1\"](%self.1)\n",
+      "))\n",
+      "(%61 : Tensor = prim::CallMethod[name=\"forward\"](%fc1, %x)\n",
+      ", 61 defined in (%61 : Tensor = prim::CallMethod[name=\"forward\"](%fc1, %x)\n",
+      "))\n",
+      "(%62 : Tensor = prim::CallMethod[name=\"forward\"](%fc2, %61)\n",
+      ", 62 defined in (%62 : Tensor = prim::CallMethod[name=\"forward\"](%fc2, %61)\n",
+      "))\n",
+      "(%63 : Tensor = prim::CallMethod[name=\"forward\"](%fc3, %62)\n",
+      ", 63 defined in (%63 : Tensor = prim::CallMethod[name=\"forward\"](%fc3, %62)\n",
+      "))\n",
+      "(%32 : int = prim::Constant[value=1]() # /tmp/ipykernel_16069/242438593.py:14:0\n",
+      ", 32 defined in (%32 : int = prim::Constant[value=1]() # /tmp/ipykernel_16069/242438593.py:14:0\n",
+      "))\n",
+      "(%input.5 : Float(1, 50, strides=[50, 1], requires_grad=1, device=cpu) = aten::add(%63, %62, %32) # /tmp/ipykernel_16069/242438593.py:14:0\n",
+      ", input.5 defined in (%input.5 : Float(1, 50, strides=[50, 1], requires_grad=1, device=cpu) = aten::add(%63, %62, %32) # /tmp/ipykernel_16069/242438593.py:14:0\n",
+      "))\n",
+      "(%64 : Tensor = prim::CallMethod[name=\"forward\"](%fc4, %input.5)\n",
+      ", 64 defined in (%64 : Tensor = prim::CallMethod[name=\"forward\"](%fc4, %input.5)\n",
+      "))\n",
+      "(%65 : Tensor = prim::CallMethod[name=\"forward\"](%fc5, %64)\n",
+      ", 65 defined in (%65 : Tensor = prim::CallMethod[name=\"forward\"](%fc5, %64)\n",
+      "))\n"
+     ]
+    }
+   ],
+   "source": [
+    "edges = []\n",
+    "for node in trace.graph.nodes():\n",
+    "    for next_node in node.outputs():\n",
+    "        edges.append((node, next_node))\n",
+    "        print(edges[-1])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "speck-rescnn",
+   "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.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

sinabs-2.0.1.dev3/tests/test_residual/test_jit_tracer_cnn.ipynb

@@ -0,0 +1,149 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class NonSeqCNN(nn.Module):\n",
+    "    def __init__(self) -> None:\n",
+    "        super().__init__()\n",
+    "        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)\n",
+    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+    "        self.conv3 = nn.Conv2d(64, 64, kernel_size=3, padding=1)\n",
+    "        self.conv4 = nn.Conv2d(64, 128, kernel_size=3, padding=1)\n",
+    "        self.conv5 = nn.Conv2d(128, 128, kernel_size=3, padding=1)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        out1 = torch.relu(self.conv1(x))\n",
+    "        out2 = torch.relu(self.conv2(out1))\n",
+    "        out3 = torch.relu(self.conv3(out2))\n",
+    "        out4 = torch.relu(self.conv4(out3))\n",
+    "        # Apply a 1x1 convolution to match dimensions for the skip connection\n",
+    "        out2_skip = torch.relu(nn.Conv2d(64, 128, kernel_size=1)(out2))\n",
+    "        # Introduce skip connection by adding outputs of conv2 and conv3\n",
+    "        out4_skip = out4 + out2_skip\n",
+    "        out5 = torch.relu(self.conv5(out4_skip))\n",
+    "        return out5\n",
+    "\n",
+    "model = NonSeqCNN()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dummy_input = torch.randn(1, 3, 32, 32)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/willian/.local/lib/python3.11/site-packages/torch/jit/_trace.py:1102: TracerWarning: Trace had nondeterministic nodes. Did you forget call .eval() on your model? Nodes:\n",
+      "\t%tensor.3 : Float(128, 64, 1, 1, strides=[64, 1, 1, 1], requires_grad=1, device=cpu) = aten::uniform_(%tensor.1, %173, %174, %175) # /home/willian/.local/lib/python3.11/site-packages/torch/nn/init.py:459:0\n",
+      "\t%bias.9 : Float(128, strides=[1], requires_grad=1, device=cpu) = aten::uniform_(%tensor, %202, %203, %204) # /home/willian/.local/lib/python3.11/site-packages/torch/nn/init.py:15:0\n",
+      "This may cause errors in trace checking. To disable trace checking, pass check_trace=False to torch.jit.trace()\n",
+      "  _check_trace(\n",
+      "/home/willian/.local/lib/python3.11/site-packages/torch/jit/_trace.py:1102: TracerWarning: Output nr 1. of the traced function does not match the corresponding output of the Python function. Detailed error:\n",
+      "Tensor-likes are not close!\n",
+      "\n",
+      "Mismatched elements: 87964 / 131072 (67.1%)\n",
+      "Greatest absolute difference: 0.22646202147006989 at index (0, 69, 20, 16) (up to 1e-05 allowed)\n",
+      "Greatest relative difference: inf at index (0, 1, 0, 1) (up to 1e-05 allowed)\n",
+      "  _check_trace(\n"
+     ]
+    }
+   ],
+   "source": [
+    "trace = torch.jit.trace(model, dummy_input)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trace_output = trace(dummy_input)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "def forward(self,\n",
+      "    x: Tensor) -> Tensor:\n",
+      "  conv5 = self.conv5\n",
+      "  conv4 = self.conv4\n",
+      "  conv3 = self.conv3\n",
+      "  conv2 = self.conv2\n",
+      "  conv1 = self.conv1\n",
+      "  input = torch.relu((conv1).forward(x, ))\n",
+      "  input0 = torch.relu((conv2).forward(input, ))\n",
+      "  input1 = torch.relu((conv3).forward(input0, ))\n",
+      "  out4 = torch.relu((conv4).forward(input1, ))\n",
+      "  data = torch.empty([128, 64, 1, 1], dtype=None, layout=None, device=torch.device(\"cpu\"), pin_memory=False)\n",
+      "  tensor = torch.detach(data)\n",
+      "  data0 = torch.empty([128], dtype=None, layout=None, device=torch.device(\"cpu\"), pin_memory=False)\n",
+      "  tensor0 = torch.detach(data0)\n",
+      "  tensor1 = torch.uniform_(tensor, -0.12499999999999999, 0.12499999999999999)\n",
+      "  bias = torch.uniform_(tensor0, -0.125, 0.125)\n",
+      "  _0 = torch._convolution(input0, tensor1, bias, [1, 1], [0, 0], [1, 1], False, [0, 0], 1, False, False, True, True)\n",
+      "  out2_skip = torch.relu(_0)\n",
+      "  input2 = torch.add(out4, out2_skip)\n",
+      "  return torch.relu((conv5).forward(input2, ))\n",
+      " <class 'str'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(trace.code, type(trace.code))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "speck-rescnn",
+   "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.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

sinabs-2.0.1.dev2/sinabs.egg-info/pbr.json

@@ -1 +0,0 @@
-{"git_version": "47d5c0b", "is_release": false}