From 4fa41539dfa48f55ea62936fe631f36c57e2cd26 Mon Sep 17 00:00:00 2001 From: loreloc Date: Thu, 12 Dec 2024 20:52:18 +0000 Subject: [PATCH] re-run notebooks --- notebooks/compilation-options.ipynb | 18 +- notebooks/learning-a-circuit-with-pic.ipynb | 32 +- notebooks/learning-a-circuit.ipynb | 4 +- notebooks/logic-circuits.ipynb | 549 +++++++++--------- .../region-graphs-and-parametrisation.ipynb | 5 +- 5 files changed, 301 insertions(+), 307 deletions(-) diff --git a/notebooks/compilation-options.ipynb b/notebooks/compilation-options.ipynb index 0ffc05a1..08896612 100644 --- a/notebooks/compilation-options.ipynb +++ b/notebooks/compilation-options.ipynb @@ -203,8 +203,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 4.58 s, sys: 1.02 s, total: 5.6 s\n", - "Wall time: 5.52 s\n" + "CPU times: user 4.78 s, sys: 1.14 s, total: 5.92 s\n", + "Wall time: 5.76 s\n" ] } ], @@ -273,7 +273,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "1.26 s ± 19.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "1.29 s ± 21.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] } ], @@ -338,8 +338,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 4.6 s, sys: 989 ms, total: 5.59 s\n", - "Wall time: 5.52 s\n" + "CPU times: user 4.68 s, sys: 915 ms, total: 5.6 s\n", + "Wall time: 5.54 s\n" ] } ], @@ -433,7 +433,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "58.9 ms ± 22.1 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + "58.9 ms ± 28.8 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] } ], @@ -527,8 +527,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 4.97 s, sys: 962 ms, total: 5.93 s\n", - "Wall time: 5.86 s\n" + "CPU times: user 4.55 s, sys: 758 ms, total: 5.31 s\n", + "Wall time: 5.25 s\n" ] } ], @@ -591,7 +591,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "25.6 ms ± 4.2 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + "25.7 ms ± 27.3 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] } ], diff --git a/notebooks/learning-a-circuit-with-pic.ipynb b/notebooks/learning-a-circuit-with-pic.ipynb index 90864e17..c91ed4da 100644 --- a/notebooks/learning-a-circuit-with-pic.ipynb +++ b/notebooks/learning-a-circuit-with-pic.ipynb @@ -29,7 +29,7 @@ "metadata": {}, "outputs": [], "source": [ - "from cirkit.templates import circuit_templates\n", + "from cirkit.templates import utils, data_modalities\n", "from cirkit.pipeline import compile\n", "import random\n", "import numpy as np\n", @@ -45,14 +45,14 @@ "# Set the torch device to use\n", "device = torch.device('cuda')\n", "\n", - "symbolic_circuit = circuit_templates.image_data(\n", + "symbolic_circuit = data_modalities.image_data(\n", " (1, 28, 28), # The shape of MNIST image, i.e., (num_channels, image_height, image_width)\n", " region_graph='quad-graph', # Select the structure of the circuit to follow the QuadGraph region graph\n", " input_layer='categorical', # Use Categorical distributions for the pixel values (0-255) as input layers\n", " num_input_units=64, # Each input layer consists of 64 Categorical input units\n", " sum_product_layer='cp', # Use CP sum-product layers, i.e., alternate dense sum layers and hadamard product layers\n", " num_sum_units=64, # Each dense sum layer consists of 64 sum units\n", - " sum_weight_param=circuit_templates.Parameterization(\n", + " sum_weight_param=utils.Parameterization(\n", " activation='none', # Do not use any parameterization\n", " initialization='normal' # Initialize the sum weights by sampling from a standard normal distribution\n", " )\n", @@ -327,17 +327,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "Step 200: Average NLL: 801.153\n", - "Step 400: Average NLL: 707.815\n", - "Step 600: Average NLL: 686.067\n", - "Step 800: Average NLL: 677.673\n", - "Step 1000: Average NLL: 664.983\n", - "Step 1200: Average NLL: 656.790\n", - "Step 1400: Average NLL: 653.522\n", - "Step 1600: Average NLL: 651.386\n", - "Step 1800: Average NLL: 650.300\n", - "Step 2000: Average NLL: 648.279\n", - "Step 2200: Average NLL: 647.581\n" + "Step 200: Average NLL: 800.724\n", + "Step 400: Average NLL: 704.707\n", + "Step 600: Average NLL: 684.442\n", + "Step 800: Average NLL: 675.654\n", + "Step 1000: Average NLL: 666.133\n", + "Step 1200: Average NLL: 656.394\n", + "Step 1400: Average NLL: 653.244\n", + "Step 1600: Average NLL: 651.271\n", + "Step 1800: Average NLL: 650.399\n", + "Step 2000: Average NLL: 648.530\n", + "Step 2200: Average NLL: 647.928\n" ] } ], @@ -393,8 +393,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average test LL: -642.370\n", - "Bits per dimension: 1.182\n" + "Average test LL: -642.912\n", + "Bits per dimension: 1.183\n" ] } ], diff --git a/notebooks/learning-a-circuit.ipynb b/notebooks/learning-a-circuit.ipynb index 10386631..ae3226cb 100644 --- a/notebooks/learning-a-circuit.ipynb +++ b/notebooks/learning-a-circuit.ipynb @@ -176,8 +176,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3.18 s, sys: 267 ms, total: 3.45 s\n", - "Wall time: 3.4 s\n" + "CPU times: user 2.65 s, sys: 322 ms, total: 2.97 s\n", + "Wall time: 2.89 s\n" ] } ], diff --git a/notebooks/logic-circuits.ipynb b/notebooks/logic-circuits.ipynb index 8b607183..73826cbb 100644 --- a/notebooks/logic-circuits.ipynb +++ b/notebooks/logic-circuits.ipynb @@ -137,7 +137,7 @@ "id": "af50f45e", "metadata": {}, "source": [ - "Converting a `LogicGraph` to a symbolic `cirkit` graph is straightforward by using the static method `cirkit.symbolic.circuit.Circuit.from_logic_graph`." + "Converting a `LogicGraph` to a symbolic `cirkit` graph is straightforward by using the method `build_circuit`." ] }, { @@ -152,72 +152,73 @@ "\n", "\n", - "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", + "%3\n", + "\n", + "\n", "\n", - "136523522918448\n", - "\n", - "0\n", + "139903286344816\n", + "\n", + "¬1\n", "\n", - "\n", - "\n", - "136523544403776\n", - "\n", - "\n", + "\n", + "\n", + "139903286344960\n", + "\n", + "+\n", "\n", - "\n", - "\n", - "136523522918448->136523544403776\n", - "\n", - "\n", + "\n", + "\n", + "139903286344816->139903286344960\n", + "\n", + "\n", "\n", - "\n", - "\n", - "136523523016896\n", - "\n", - "+\n", + "\n", + "\n", + "139903286345008\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "136523523016896->136523544403776\n", - "\n", - "\n", + "139903286344960->139903286345008\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "136523522929920\n", - "\n", - "¬1\n", + "139903286344480\n", + "\n", + "2\n", "\n", - "\n", - "\n", - "136523522929920->136523523016896\n", - "\n", - "\n", + "\n", + "\n", + "139903286344480->139903286344960\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "136523533880160\n", - "\n", - "2\n", + "139903286344144\n", + "\n", + "0\n", "\n", - "\n", - "\n", - "136523533880160->136523523016896\n", - "\n", - "\n", + "\n", + "\n", + "139903286344144->139903286345008\n", + "\n", + "\n", "\n", "\n", "\n" ], "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -227,13 +228,14 @@ ], "source": [ "from cirkit.symbolic.circuit import Circuit\n", + "from cirkit.symbolic.io import plot_circuit\n", "\n", "def literal_label(layer):\n", - " prefix = \"¬\" if layer.probs.output.value.squeeze().tolist() == [1.0, 0.0] else \"\"\n", + " prefix = \"¬\" if layer.probs.output.initializer.value.squeeze().tolist() == [1.0, 0.0] else \"\"\n", " return f\"{prefix}{next(iter(layer.scope))}\"\n", "\n", - "circuit = Circuit.from_logic_circuit(alpha_graph, enforce_smoothness=False)\n", - "circuit.plot(input_label=literal_label)" + "circuit = alpha_graph.build_circuit(enforce_smoothness=False)\n", + "plot_circuit(circuit, input_label=literal_label)" ] }, { @@ -334,7 +336,7 @@ { "data": { "text/plain": [ - "tensor([[[1.]]])" + "tensor([[[1.]]], grad_fn=)" ] }, "execution_count": 5, @@ -365,7 +367,7 @@ { "data": { "text/plain": [ - "tensor([[[0.]]])" + "tensor([[[0.]]], grad_fn=)" ] }, "execution_count": 6, @@ -432,7 +434,7 @@ } ], "source": [ - "smooth_circuit = Circuit.from_logic_circuit(alpha_graph, enforce_smoothness=True)\n", + "smooth_circuit = alpha_graph.build_circuit(enforce_smoothness=True)\n", "\n", "with ctx:\n", " smooth_compiled_circuit = compile(smooth_circuit)\n", @@ -459,17 +461,17 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 9, "id": "97fd5510", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([[[2.]]])" + "tensor([[[2.]]], grad_fn=)" ] }, - "execution_count": 21, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -480,17 +482,17 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 10, "id": "1317d38b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([[[2.]]])" + "tensor([[[2.]]], grad_fn=)" ] }, - "execution_count": 22, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -515,16 +517,10 @@ "\n", "We will rely on the [pySDD](https://github.com/ML-KULeuven/PySDD) library to compile propositional formulas to SDD circuits, exploiting the [official SDD compiler](http://reasoning.cs.ucla.edu/sdd/). \n", "\n", - "You can install pySDD with\n", + "You can install pySDD with the following command.\n", "\n", "```\n", "$ pip install PySDD\n", - "```\n", - "\n", - "additionally, we will visualize the boolean circuit using graphviz, which can be installed using \n", - "\n", - "```\n", - "$ pip install graphviz\n", "```" ] }, @@ -539,7 +535,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 11, "id": "0ebb8e3a", "metadata": {}, "outputs": [ @@ -549,70 +545,70 @@ "\n", "\n", - "\n", "\n", "\n", - "\n", + " viewBox=\"0.00 0.00 78.00 129.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n", + "\n", "vtree\n", - "\n", + "\n", "\n", "\n", "n1\n", - "1\n", + "1\n", "\n", "\n", "\n", "n0\n", - "A\n", + "A\n", "\n", "\n", "\n", "n1->n0\n", - "\n", - "0\n", + "\n", + "0\n", "\n", "\n", "\n", "n3\n", - "3\n", + "3\n", "\n", "\n", "\n", "n1->n3\n", - "\n", + "\n", "\n", "\n", "\n", "n2\n", - "B\n", + "B\n", "\n", "\n", "\n", "n3->n2\n", - "\n", - "2\n", + "\n", + "2\n", "\n", "\n", "\n", "n4\n", - "C\n", + "C\n", "\n", "\n", "\n", "n3->n4\n", - "\n", - "4\n", + "\n", + "4\n", "\n", "\n", "\n" ], "text/plain": [ - "" + "" ] }, - "execution_count": 23, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -644,7 +640,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 12, "id": "8cc2e96e", "metadata": {}, "outputs": [ @@ -654,97 +650,97 @@ "\n", "\n", - "\n", "\n", - "\n", - "\n", + "\n", + "\n", "sdd\n", - "\n", + "\n", "\n", "\n", "n9\n", - "\n", - "3\n", + "\n", + "3\n", "\n", "\n", "\n", "n9e0\n", - "\n", - "B\n", - "\n", - "C\n", + "\n", + "B\n", + "\n", + "C\n", "\n", "\n", "\n", "n9->n9e0\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", "\n", "n9e1\n", - "\n", - "¬B\n", - "\n", - "\n", + "\n", + "¬B\n", + "\n", + "\n", "\n", "\n", "\n", "n9->n9e1\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", "\n", "n10\n", - "\n", - "1\n", + "\n", + "1\n", "\n", "\n", "\n", "n10e0\n", - "\n", - "A\n", - "\n", - " \n", + "\n", + "A\n", + "\n", + " \n", "\n", "\n", "\n", "n10->n10e0\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", "\n", "n10e1\n", - "\n", - "¬A\n", - "\n", - "\n", + "\n", + "¬A\n", + "\n", + "\n", "\n", "\n", "\n", "n10->n10e1\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", "\n", "n10e0:c->n9\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", "\n", "\n" ], "text/plain": [ - "" + "" ] }, - "execution_count": 24, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -783,7 +779,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 13, "id": "6a7a64c6", "metadata": {}, "outputs": [], @@ -805,12 +801,12 @@ "id": "a4a7602a", "metadata": {}, "source": [ - "We can now use `Circuit.from_logic_graph` just like we did previosly." + "We can now use `build_circuit` just like we did previously." ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 14, "id": "a3790b49", "metadata": {}, "outputs": [ @@ -820,184 +816,183 @@ "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", "\n", - "\n", - "\n", + "%3\n", + "\n", + "\n", "\n", - "136523545639968\n", - "\n", - "\n", + "139900346381840\n", + "\n", + "\n", "\n", - "\n", - "\n", - "136523545640208\n", - "\n", - "+\n", + "\n", + "\n", + "139900346382272\n", + "\n", + "+\n", "\n", - "\n", - "\n", - "136523545639968->136523545640208\n", - "\n", - "\n", + "\n", + "\n", + "139900346381840->139900346382272\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "136523545640496\n", - "\n", - "+\n", + "139900346375456\n", + "\n", + "0\n", "\n", - "\n", - "\n", - "136523545634400\n", - "\n", - "2\n", + "\n", + "\n", + "139900346375456->139900346381840\n", + "\n", + "\n", "\n", - "\n", - "\n", - "136523545639536\n", - "\n", - "\n", + "\n", + "\n", + "139900346381792\n", + "\n", + "+\n", "\n", - "\n", + "\n", "\n", - "136523545634400->136523545639536\n", - "\n", - "\n", + "139900346381792->139900346381840\n", + "\n", + "\n", "\n", - "\n", - "\n", - "136523545639728\n", - "\n", - "+\n", + "\n", + "\n", + "139900346374688\n", + "\n", + "+\n", "\n", - "\n", - "\n", - "136523545634400->136523545639728\n", - "\n", - "\n", + "\n", + "\n", + "139900346379920\n", + "\n", + "\n", "\n", - "\n", - "\n", - "136523545639536->136523545640208\n", - "\n", - "\n", + "\n", + "\n", + "139900346374688->139900346379920\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "136523545633968\n", - "\n", - "¬1\n", + "139900346381408\n", + "\n", + "2\n", "\n", - "\n", - "\n", - "136523545633968->136523545639968\n", - "\n", - "\n", + "\n", + "\n", + "139900346381408->139900346374688\n", + "\n", + "\n", "\n", - "\n", - "\n", - "136523545639632\n", - "\n", - "+\n", + "\n", + "\n", + "139900346377808\n", + "\n", + "\n", "\n", - "\n", - "\n", - "136523545633968->136523545639632\n", - "\n", - "\n", + "\n", + "\n", + "139900346381408->139900346377808\n", + "\n", + "\n", "\n", - "\n", - "\n", - "136523545640160\n", - "\n", - "\n", + "\n", + "\n", + "139900346373104\n", + "\n", + "¬2\n", "\n", - "\n", - "\n", - "136523545640160->136523545640496\n", - "\n", - "\n", + "\n", + "\n", + "139900346373104->139900346374688\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "136523545640208->136523545640160\n", - "\n", - "\n", + "139900346377808->139900346381792\n", + "\n", + "\n", "\n", - "\n", - "\n", - "136523545639728->136523545639968\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "136523545639248\n", - "\n", - "¬2\n", + "\n", + "\n", + "139900346376464\n", + "\n", + "1\n", "\n", - "\n", - "\n", - "136523545639248->136523545639728\n", - "\n", - "\n", + "\n", + "\n", + "139900346376464->139900346377808\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "136523545636704\n", - "\n", - "0\n", + "139900346370224\n", + "\n", + "+\n", "\n", - "\n", - "\n", - "136523545636704->136523545640160\n", - "\n", - "\n", + "\n", + "\n", + "139900346376464->139900346370224\n", + "\n", + "\n", "\n", - "\n", - "\n", - "136523545638864\n", - "\n", - "1\n", + "\n", + "\n", + "139900346379920->139900346381792\n", + "\n", + "\n", "\n", - "\n", - "\n", - "136523545638864->136523545639536\n", - "\n", - "\n", + "\n", + "\n", + "139900346379680\n", + "\n", + "¬1\n", "\n", - "\n", - "\n", - "136523545638864->136523545639632\n", - "\n", - "\n", + "\n", + "\n", + "139900346379680->139900346379920\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "139900346379680->139900346370224\n", + "\n", + "\n", "\n", "\n", "\n" ], "text/plain": [ - "" + "" ] }, - "execution_count": 26, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def literal_label(layer):\n", - " prefix = \"¬\" if layer.probs.output.value.squeeze().tolist() == [1.0, 0.0] else \"\"\n", + " prefix = \"¬\" if layer.probs.output.initializer.value.squeeze().tolist() == [1.0, 0.0] else \"\"\n", " return f\"{prefix}{next(iter(layer.scope))}\"\n", "\n", - "alpha_sdd_circuit = Circuit.from_logic_circuit(alpha_sdd)\n", - "alpha_sdd_circuit.plot(\n", - " input_label=literal_label\n", - ")" + "alpha_sdd_circuit = alpha_sdd.build_circuit()\n", + "plot_circuit(alpha_sdd_circuit, input_label=literal_label)" ] }, { @@ -1010,7 +1005,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 15, "id": "c26beb39", "metadata": {}, "outputs": [ @@ -1020,7 +1015,7 @@ "StructuralProperties(smooth=True, decomposable=True, structured_decomposable=True, omni_compatible=False)" ] }, - "execution_count": 27, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -1045,17 +1040,17 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 16, "id": "0a4cae92", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([[[3.]]])" + "tensor([[[3.]]], grad_fn=)" ] }, - "execution_count": 28, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -1089,17 +1084,17 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 17, "id": "20dbba09", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([[[0.]]])" + "tensor([[[0.]]], grad_fn=)" ] }, - "execution_count": 29, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -1113,17 +1108,17 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 18, "id": "1488411a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([[[0.]]])" + "tensor([[[0.]]], grad_fn=)" ] }, - "execution_count": 30, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -1134,17 +1129,17 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 19, "id": "d4aae365", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([[[0.]]])" + "tensor([[[0.]]], grad_fn=)" ] }, - "execution_count": 31, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1155,17 +1150,17 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 20, "id": "6120e3e5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([[[0.]]])" + "tensor([[[0.]]], grad_fn=)" ] }, - "execution_count": 32, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1185,7 +1180,7 @@ ], "metadata": { "kernelspec": { - "display_name": "cirkit", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1199,7 +1194,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.0" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/notebooks/region-graphs-and-parametrisation.ipynb b/notebooks/region-graphs-and-parametrisation.ipynb index 35a8cc9b..6c48aa7f 100644 --- a/notebooks/region-graphs-and-parametrisation.ipynb +++ b/notebooks/region-graphs-and-parametrisation.ipynb @@ -98,7 +98,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -374,8 +374,7 @@ " # input from more than one layer are parameterized such that they compute a convex combination of the input vectors.\n", " nary_sum_weight_factory = functools.partial(mixing_weight_factory, param_factory=sum_weight_factory)\n", "\n", - " circuit = Circuit.from_region_graph(\n", - " rg,\n", + " circuit = rg.build_circuit(\n", " input_factory=input_factory,\n", " sum_weight_factory=sum_weight_factory,\n", " nary_sum_weight_factory=nary_sum_weight_factory,\n",