From 45e9ccd63d0aa6f7076afc7f95dd2127e44f1aa6 Mon Sep 17 00:00:00 2001 From: "spaceBearAmadeus (Alex)" Date: Mon, 30 Dec 2024 11:03:09 -0500 Subject: [PATCH] update kernel spec in compose server --- .dockerignore | 1 + .gitignore | 1 + assets/dev/scripts/add_env_kernel.sh | 17 + assets/dev/scripts/install.sh | 6 +- bio_bundles/quantum/__init__.py | 3 + bio_bundles/quantum/data_model.py | 17 + bio_bundles/quantum/test_quantum.ipynb | 39 ++ environment.yml | 31 +- pyproject | 46 +++ pyproject.toml | 92 +++-- qaoa_process.ipynb | 506 +++++++++++++++++++++++++ tests/quantum.ipynb | 227 +++++++++++ 12 files changed, 950 insertions(+), 36 deletions(-) create mode 100755 assets/dev/scripts/add_env_kernel.sh create mode 100644 bio_bundles/quantum/__init__.py create mode 100644 bio_bundles/quantum/data_model.py create mode 100644 bio_bundles/quantum/test_quantum.ipynb create mode 100644 pyproject create mode 100644 qaoa_process.ipynb create mode 100644 tests/quantum.ipynb diff --git a/.dockerignore b/.dockerignore index c1811ee4d..488152102 100644 --- a/.dockerignore +++ b/.dockerignore @@ -15,6 +15,7 @@ nosetests.xml coverage.xml *.cover *.log +.ipynb_checkpoints .git .mypy_cache .pytest_cache diff --git a/.gitignore b/.gitignore index d77fe4376..e8471c6c8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ +.ipynb_checkpoints release_env commit.sh .idea/ diff --git a/assets/dev/scripts/add_env_kernel.sh b/assets/dev/scripts/add_env_kernel.sh new file mode 100755 index 000000000..761ffb3a6 --- /dev/null +++ b/assets/dev/scripts/add_env_kernel.sh @@ -0,0 +1,17 @@ +#!/usr/bin/env bash + +env="$1" + +if [ "$env" == "" ]; then + env=$(conda env list | grep '*' | awk '{print $1}') +fi + +# install ipykernel if needed +kernel=$(conda list | grep ipykernel) + +if [ "$kernel" == "" ]; then + conda run -n "$env" pip install ipykernel jupyterlab +fi + +python_version=$(conda run -n "$env" python --version) +conda run -n "$env" python -m ipykernel install --user --name="$env" --display-name "BioCompose Server($env): Python$python_version" diff --git a/assets/dev/scripts/install.sh b/assets/dev/scripts/install.sh index 3258ba422..5a96af766 100755 --- a/assets/dev/scripts/install.sh +++ b/assets/dev/scripts/install.sh @@ -15,7 +15,7 @@ if [ "$platform" == "Darwin" ]; then fi # install deps from pyproject and activate env -conda run -n bio-compose-server pip install --upgrade pip -conda run -n bio-compose-server pip install -e . -conda activate bio-compose-server +conda run -n server pip install --upgrade pip +conda run -n server pip install -e . +conda activate server diff --git a/bio_bundles/quantum/__init__.py b/bio_bundles/quantum/__init__.py new file mode 100644 index 000000000..b28b04f64 --- /dev/null +++ b/bio_bundles/quantum/__init__.py @@ -0,0 +1,3 @@ + + + diff --git a/bio_bundles/quantum/data_model.py b/bio_bundles/quantum/data_model.py new file mode 100644 index 000000000..d8a239bdc --- /dev/null +++ b/bio_bundles/quantum/data_model.py @@ -0,0 +1,17 @@ +import numpy as np + + +class DiracNotation(np.ndarray): + def __new__(cls, values: list[complex]): + return np.asarray(values).view(cls) + + +class Bra(DiracNotation): + pass + + +class Ket(DiracNotation): + def bra(self) -> Bra: + ket_value = self.view() + return Bra(np.conj(ket_value).T) + diff --git a/bio_bundles/quantum/test_quantum.ipynb b/bio_bundles/quantum/test_quantum.ipynb new file mode 100644 index 000000000..3b5755682 --- /dev/null +++ b/bio_bundles/quantum/test_quantum.ipynb @@ -0,0 +1,39 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "raw", + "source": "from process_bigraph", + "id": "f3a9e63ddcc7d864" + }, + { + "metadata": { + "jupyter": { + "is_executing": true + } + }, + "cell_type": "code", + "source": "from process_bigraph import Process, Step, Composite", + "id": "21fa17e759c94d71", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "92c51098889dfb08" + } + ], + "metadata": { + "kernelspec": { + "name": "python3", + "language": "python", + "display_name": "Python 3 (ipykernel)" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/environment.yml b/environment.yml index 467277540..80c08402f 100644 --- a/environment.yml +++ b/environment.yml @@ -1,4 +1,4 @@ -name: bio-compose-server +name: server channels: - defaults - https://repo.anaconda.com/pkgs/main @@ -8,5 +8,34 @@ channels: dependencies: - pip - python=3.10 + - poetry # - readdy # - pymem3dg + - pip: + - uvicorn + - fastapi + - mypy + - pytest + - pip-autoremove + - networkx + - rustworkx + - qiskit + - qiskit-ibm-runtime + - numpy + - pandas + - process-bigraph + - copasi-basico + - tellurium + - python-libsbml + - smoldyn + - requests-toolbelt + - python-dotenv + - google-cloud-storage + - python-multipart + - toml + - typing-extensions + - pymongo + - pydantic + - pydantic-settings + - chardet + - pyyaml diff --git a/pyproject b/pyproject new file mode 100644 index 000000000..7499720a4 --- /dev/null +++ b/pyproject @@ -0,0 +1,46 @@ +[project] +name = "bio-compose-server" +version = "0.0.1" +readme ="README.md" +description = "Backend for BioCompose: a microservices-based data service leveraging Kubernetes for efficient orchestration of bio-chemical simulation comparisons." +authors = [{name = "Alex Patrie", email = "alex@example.com"}] + +# only app-level deps +dependencies = [ + "requests-toolbelt", + "python-dotenv", + "google-cloud-storage", + "python-multipart", + "fastapi", + "toml", + "typing-extensions", + "pymongo", + "pydantic-settings", + "pydantic", + "uvicorn", + "pyyaml", + "chardet", + "simulariumio", + "numpy", + "pandas", + "process-bigraph==0.0.22", + "bigraph-schema", + "copasi-basico", + "tellurium", + "python-libsbml", + "smoldyn", + "pip-autoremove", + "networkx", + "qiskit", + "qiskit-ibm-runtime", + "mypy" +] + + +[tool.setuptools] +packages = ["bio_bundles", "gateway", "shared", "tests", "worker"] + + +[build-system] +requires = ["setuptools>=61.0", "wheel"] +build-backend = "setuptools.build_meta" diff --git a/pyproject.toml b/pyproject.toml index 8abc196b3..e498d80d4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,42 +1,70 @@ -[project] +[tool.poetry] name = "bio-compose-server" version = "0.0.1" readme ="README.md" description = "Backend for BioCompose: a microservices-based data service leveraging Kubernetes for efficient orchestration of bio-chemical simulation comparisons." -authors = [{name = "Alex Patrie", email = "alex@example.com"}] - -# only app-level deps -dependencies = [ - "requests-toolbelt", - "python-dotenv", - "google-cloud-storage", - "python-multipart", - "fastapi", - "toml", - "typing-extensions", - "pymongo", - "pydantic-settings", - "pydantic", - "uvicorn", - "pyyaml", - "chardet", - "simulariumio", - "numpy", - "pandas", - "process-bigraph==0.0.22", - "bigraph-schema", - "copasi-basico", - "tellurium", - "python-libsbml", - "smoldyn", - "pip-autoremove" +authors = ["Alex Patrie "] +packages = [ + {include ="bio_bundles"}, + {include ="gateway"}, + {include ="shared"}, + {include ="tests"}, + {include ="worker"} ] -[tool.setuptools] -packages = ["bio_bundles", "gateway", "shared", "tests", "worker"] +[tool.poetry.dependencies] +python = ">=3.10" + + +[tool.poetry.group.api.dependencies] +uvicorn = "*" +fastapi = "^0.115.6" + + +[tool.poetry.group.dev.dependencies] +mypy = "*" +pytest = "*" +pip-autoremove = "*" + + +[tool.poetry.group.quantum.dependencies] +jupyterlab = "*" +ipykernel = "*" + + +[tool.poetry.group.quantum.dependencies] +networkx = "*" +rustworkx = "*" +qiskit = "*" +qiskit-ibm-runtime = "*" + + +[tool.poetry.group.simulators.dependencies] +numpy = "*" +pandas = "*" +process-bigraph = "*" +bigraph-schema = "*" +copasi-basico = "*" +tellurium = "*" +python-libsbml = "*" +smoldyn = "*" + + +[tool.poetry.group.shared.dependencies] +requests-toolbelt = "^1.0.0" +python-dotenv = "^1.0.1" +google-cloud-storage = "^2.19.0" +python-multipart = "^0.0.20" +toml = "^0.10.2" +typing-extensions = "^4.12.2" +pymongo = "^4.10.1" +pydantic-settings = "^2.7.0" +pydantic = "^2.10.4" +chardet = "*" +pyyaml = "*" [build-system] -requires = ["setuptools>=61.0", "wheel"] -build-backend = "setuptools.build_meta" +requires = ["poetry-core"] +build-backend = "poetry.core.masonry.api" diff --git a/qaoa_process.ipynb b/qaoa_process.ipynb new file mode 100644 index 000000000..2ade9eab3 --- /dev/null +++ b/qaoa_process.ipynb @@ -0,0 +1,506 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "id": "ca6612cb-4390-44ab-adb2-52347b0f0e6e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cannot register OutputGenerator. Error:\n", + "**\n", + "No module named 'bio_bundles.steps.main'\n", + "**\n", + "Cannot register TimeCourseOutputGenerator. Error:\n", + "**\n", + "No module named 'bio_bundles.steps.main'\n", + "**\n", + "Cannot register SmoldynStep. Error:\n", + "**\n", + "No module named 'bio_bundles.steps.main'\n", + "**\n", + "Cannot register SimulariumSmoldynStep. Error:\n", + "**\n", + "No module named 'bio_bundles.steps.main'\n", + "**\n", + "Cannot register MongoDatabaseEmitter. Error:\n", + "**\n", + "No module named 'bio_bundles.steps.main'\n", + "**\n", + "Cannot register CopasiStep. Error:\n", + "**\n", + "No module named 'amici'\n", + "**\n", + "Cannot register TelluriumStep. Error:\n", + "**\n", + "No module named 'amici'\n", + "**\n", + "Cannot register AmiciStep. Error:\n", + "**\n", + "No module named 'amici'\n", + "**\n", + "Cannot register UtcComparator. Error:\n", + "**\n", + "No module named 'biosimulators_processes'\n", + "**\n", + "Cannot register SmoldynStep. Error:\n", + "**\n", + "No module named 'biosimulators_processes'\n", + "**\n", + "Cannot register SimulariumSmoldynStep. Error:\n", + "**\n", + "No module named 'biosimulators_processes'\n", + "**\n", + "Cannot register MongoDatabaseEmitter. Error:\n", + "**\n", + "No module named 'biosimulators_processes'\n", + "**\n", + "Cannot register CobraProcess. Error:\n", + "**\n", + "No module named 'cobra'\n", + "**\n", + "Cannot register CopasiProcess. Error:\n", + "**\n", + "No module named 'biosimulators_processes'\n", + "**\n", + "Cannot register TelluriumProcess. Error:\n", + "**\n", + "No module named 'biosimulators_processes'\n", + "**\n", + "Cannot register UtcAmici. Error:\n", + "**\n", + "No module named 'seaborn'\n", + "**\n", + "Cannot register UtcCopasi. Error:\n", + "**\n", + "No module named 'biosimulators_processes'\n", + "**\n", + "Cannot register UtcTellurium. Error:\n", + "**\n", + "No module named 'biosimulators_processes'\n", + "**\n", + "Cannot register SmoldynProcess. Error:\n", + "**\n", + "No module named 'biosimulators_processes'\n", + "**\n", + "Cannot register SmoldynIOProcess. Error:\n", + "**\n", + "No module named 'biosimulators_processes'\n", + "**\n" + ] + } + ], + "source": [ + "from process_bigraph import Process, Composite, Step\n", + "import bio_bundles\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7be4e5fe-4eda-40c9-8b21-853d54adf784", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['AbstractSet',\n", + " 'Annotated',\n", + " 'Any',\n", + " 'AnyStr',\n", + " 'AsyncContextManager',\n", + " 'AsyncGenerator',\n", + " 'AsyncIterable',\n", + " 'AsyncIterator',\n", + " 'Awaitable',\n", + " 'BinaryIO',\n", + " 'ByteString',\n", + " 'Callable',\n", + " 'ChainMap',\n", + " 'ClassVar',\n", + " 'Collection',\n", + " 'Concatenate',\n", + " 'Container',\n", + " 'ContextManager',\n", + " 'Coroutine',\n", + " 'Counter',\n", + " 'DefaultDict',\n", + " 'Deque',\n", + " 'Dict',\n", + " 'Final',\n", + " 'ForwardRef',\n", + " 'FrozenSet',\n", + " 'Generator',\n", + " 'Generic',\n", + " 'Hashable',\n", + " 'IO',\n", + " 'ItemsView',\n", + " 'Iterable',\n", + " 'Iterator',\n", + " 'KeysView',\n", + " 'List',\n", + " 'Literal',\n", + " 'MODEL_TYPE',\n", + " 'Mapping',\n", + " 'MappingView',\n", + " 'Match',\n", + " 'MutableMapping',\n", + " 'MutableSequence',\n", + " 'MutableSet',\n", + " 'NamedTuple',\n", + " 'NewType',\n", + " 'NoReturn',\n", + " 'Optional',\n", + " 'OrderedDict',\n", + " 'PROCESS_IMPLEMENTATIONS',\n", + " 'ParamSpec',\n", + " 'ParamSpecArgs',\n", + " 'ParamSpecKwargs',\n", + " 'Pattern',\n", + " 'ProcessTypes',\n", + " 'Protocol',\n", + " 'Registrar',\n", + " 'Reversible',\n", + " 'STEP_IMPLEMENTATIONS',\n", + " 'Sequence',\n", + " 'Set',\n", + " 'Sized',\n", + " 'SupportsAbs',\n", + " 'SupportsBytes',\n", + " 'SupportsComplex',\n", + " 'SupportsFloat',\n", + " 'SupportsIndex',\n", + " 'SupportsInt',\n", + " 'SupportsRound',\n", + " 'TYPE_CHECKING',\n", + " 'Text',\n", + " 'TextIO',\n", + " 'Tuple',\n", + " 'Type',\n", + " 'TypeAlias',\n", + " 'TypeGuard',\n", + " 'TypeVar',\n", + " 'TypedDict',\n", + " 'UTC_CONFIG_TYPE',\n", + " 'Union',\n", + " 'ValuesView',\n", + " '__builtins__',\n", + " '__cached__',\n", + " '__doc__',\n", + " '__file__',\n", + " '__loader__',\n", + " '__name__',\n", + " '__package__',\n", + " '__path__',\n", + " '__spec__',\n", + " 'cast',\n", + " 'data_model',\n", + " 'final',\n", + " 'get_args',\n", + " 'get_origin',\n", + " 'get_type_hints',\n", + " 'importlib',\n", + " 'is_typeddict',\n", + " 'no_type_check',\n", + " 'no_type_check_decorator',\n", + " 'overload',\n", + " 'processes',\n", + " 'registrar',\n", + " 'registry',\n", + " 'runtime_checkable',\n", + " 'smoldyn',\n", + " 'steps']" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dir(bio_bundles)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d96bec83-feb3-4e0d-90d7-371fa0a043ae", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a3857580-7117-41a8-b58e-3460e3ca3824", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "23d005d8-a900-4154-8a8c-a31ffebd73e2", + "metadata": {}, + "outputs": [ + { + "ename": "IndentationError", + "evalue": "expected an indented block after function definition on line 14 (3854564678.py, line 17)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m Cell \u001b[0;32mIn[11], line 17\u001b[0;36m\u001b[0m\n\u001b[0;31m class QAOA(Process):\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block after function definition on line 14\n" + ] + } + ], + "source": [ + "from bio_bundles import registrar\n", + "from bio_bundles.data_model import BaseClass\n", + "\n", + "from typing import *\n", + "\n", + "import networkx as nx\n", + "from qiskit.circuit.library import TwoLocal\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "\n", + "\n", + "CORE = registrar.core\n", + "\n", + "\n", + "@dataclass\n", + "class Problem(BaseClass):\n", + " pass\n", + "\n", + "\n", + "@dataclass\n", + "class NVariableProblem(Problem):\n", + " n_vars: int\n", + " inputs: Optional[Dict] = None\n", + "\n", + " def __post_init__(self):\n", + " self.inputs = self.get_input_data()\n", + "\n", + " def get_input_data(self, *args, **kwargs):\n", + " # TODO: perform some logic here to format Nvar problem\n", + " return {}\n", + "\n", + " \n", + "class QAOA(Process):\n", + " # same here (format n var prob)\n", + " config_schema = {\n", + " 'num_nodes': 'integer',\n", + " 'max_depth': 'integer'\n", + " }\n", + "\n", + " def __init__(self, config, core):\n", + " # TODO: make n_vars mapped more to real\n", + " super().__init__(config, core)\n", + "\n", + " # TODO: infer this from the given composite.json file as input.\n", + " self.max_depth = self.config.get(\"max_depth\", 3)\n", + " self.N = self.config[\"num_nodes\"]\n", + " self.graph = nx.complete_graph(self.N)\n", + "\n", + " # define optimizer\n", + " self.optimizer = COBYLA()\n", + "\n", + " def initial_state(self):\n", + " # get initial problem hamiltonian from weights set in init\n", + " initial_h_problem = self._get_problem_hamiltonian()\n", + " \n", + " # get mixer hamiltonian from current N(self.N)\n", + " initial_h_mixer = self._get_mixer_hamiltonian(self.N)\n", + " \n", + " # get intitial ansatz\n", + " initial_ansatz = self._get_ansatz(self.N)\n", + "\n", + " return {\n", + " \"H_P\": initial_h_problem,\n", + " \"H_M\": initial_h_mixer,\n", + " \"ansatz\" initial_ansatz\n", + " }\n", + " \n", + " def inputs(self):\n", + " return {\n", + " \"H_P\":{}}\n", + "\n", + " def outputs(self):\n", + " return {}\n", + "\n", + " def _get_problem_hamiltonian(self):\n", + " h = 0\n", + " for i, j in self.graph.edges():\n", + " weight = self.graph[i][j]['weight']\n", + " h += weight * (0.5 * (1 - Z(i) @ Z(j)))\n", + " return h\n", + "\n", + " def _get_mixer_hamiltonian(self, N: int):\n", + " return sum([X(i) for i in range(N)])\n", + "\n", + " def _get_ansatz(self, N: int):\n", + " return TwoLocal(N, 'ry', 'cz', reps=self.max_depth, entanglement='linear')\n", + " \n", + " def _compute_edge_weight(a, b):\n", + " # TODO: implement this, for now returing random\n", + " return np.random.rand()\n", + "\n", + " def check_n(self):\n", + " pass\n", + "\n", + " \n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6fb26dcb-3ffb-4114-9a37-581013829fe9", + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "\n", + "G = nx.complete_graph(4)\n", + "G.edges()\n", + "for u, v in G.edges():\n", + " edge = G[u][v]\n", + " edge['weight'] = 10\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "0e3fe572-6a4d-462f-abc0-b16927afaa86", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "G" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "ffaac0c2-fecf-4196-9926-6c1877b86a19", + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'qiskit.opflow'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[20], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mqiskit\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mopflow\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Z, I\n\u001b[1;32m 2\u001b[0m H_P \u001b[38;5;241m=\u001b[39m \u001b[38;5;28msum\u001b[39m([w_ij \u001b[38;5;241m*\u001b[39m (\u001b[38;5;241m0.5\u001b[39m \u001b[38;5;241m*\u001b[39m (I \u001b[38;5;241m-\u001b[39m Z(i) \u001b[38;5;241m@\u001b[39m Z(j))) \u001b[38;5;28;01mfor\u001b[39;00m i, j \u001b[38;5;129;01min\u001b[39;00m graph\u001b[38;5;241m.\u001b[39medges()])\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'qiskit.opflow'" + ] + } + ], + "source": [ + "from qiskit.opflow import Z, I\n", + "H_P = sum([w_ij * (0.5 * (I - Z(i) @ Z(j))) for i, j in graph.edges()])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "0d755920-e6f1-4add-9551-53d633904e8b", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import ZGate" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "7b74068b-b7d8-412c-aedf-8f1a71799169", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import rustworkx as rx\n", + "from rustworkx.visualization import mpl_draw as draw_graph\n", + "N = 5\n", + "graph = rx.PyGraph()\n", + "graph.add_nodes_from(np.arange(0, N, 1))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "5fbb3406-9844-4dc1-a36f-35aafc1da17d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "edge_list = [(0, 1, 1.0), (0, 2, 1.0), (0, 4, 1.0), (1, 2, 1.0), (2, 3, 1.0), (3, 4, 0.0)]\n", + "graph.add_edges_from(edge_list)\n", + "draw_graph(graph, node_size=600, with_labels=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "391d4d7f-b537-43e2-ad64-93ec7a3792b2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bio-compose-server", + "language": "python", + "name": "bio-compose-server" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/quantum.ipynb b/tests/quantum.ipynb new file mode 100644 index 000000000..9b5033571 --- /dev/null +++ b/tests/quantum.ipynb @@ -0,0 +1,227 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "807877d8-0478-4cfc-8beb-76b8384eec4f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: networkx in /Users/alexanderpatrie/miniforge3/envs/bio-compose-server/lib/python3.10/site-packages (3.4.2)\n" + ] + } + ], + "source": [ + "!pip install networkx" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "88d944d9-23f2-419f-a6b7-d465093d8441", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import networkx as nx\n", + "\n", + "\n", + "num_people = 6\n", + "\n", + "names = ['alex', 'ross', 'lauren', 'kayla']\n", + "\n", + "people = {\n", + " \"alex\": 0.75,\n", + " \"kayla\": 0.6,\n", + " \"lauren\": 0.9,\n", + " \"ross\": 0.0\n", + "}\n", + "\n", + "w = np.array(\n", + " [[0.0, 1.0, 1.0, 0.0], [1.0, 0.0, 1.0, 1.0], [1.0, 1.0, 0.0, 1.0], [0.0, 1.0, 1.0, 0.0]]\n", + ")\n", + "\n", + "G = nx.from_numpy_array(w)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "24d7e997-602b-4046-9eeb-92522810d730", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adjacency Matrix:\n", + "[[0. 0.86956522 0.86956522 0.57142857]\n", + " [0.86956522 0. 0.76923077 0.625 ]\n", + " [0.86956522 0.76923077 0. 0.52631579]\n", + " [0.57142857 0.625 0.52631579 0. ]]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import networkx as nx\n", + "\n", + "# Define the people and their associated values\n", + "people = {\n", + " \"alex\": 0.75,\n", + " \"kayla\": 0.6,\n", + " \"lauren\": 0.9,\n", + " \"ross\": 0.0\n", + "}\n", + "\n", + "# List the names to create a consistent order\n", + "people_list = list(people.keys())\n", + "\n", + "# Create an empty adjacency matrix\n", + "n = len(people_list)\n", + "w = np.zeros((n, n))\n", + "\n", + "# Define the function to calculate similarity which is what edges will be based on (inverse of absolute difference)\n", + "def calculate_similarity(val1, val2):\n", + " return 1 / (1 + abs(val1 - val2)) # Example similarity function\n", + "\n", + "# Populate the adjacency matrix\n", + "for i in range(n):\n", + " for j in range(i + 1, n): # Only upper triangle because adjacency matrix is symmetric\n", + " val_i = people[people_list[i]]\n", + " val_j = people[people_list[j]]\n", + " similarity = calculate_similarity(val_i, val_j)\n", + " w[i, j] = w[j, i] = similarity # Since the graph is undirected\n", + "\n", + "# Now you have the adjacency matrix 'w'\n", + "print(\"Adjacency Matrix:\")\n", + "print(w)\n", + "\n", + "# Create the graph using NetworkX\n", + "G = nx.from_numpy_array(w)\n", + "\n", + "# Optionally, you can plot the graph to visualize it\n", + "import matplotlib.pyplot as plt\n", + "\n", + "nx.draw(G, with_labels=True, labels={i: people_list[i] for i in range(len(people_list))})\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c11092dd-2958-4675-8be6-f4c2c365f54a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_nodes = len(people.keys())\n", + "\n", + "num_nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "dd95d183-ed75-4097-bcb0-5286fc34e60f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Objective value computed by the brute-force method is 4\n" + ] + } + ], + "source": [ + "def objective_value(x, w):\n", + " \"\"\"Compute the value of a cut.\n", + " Args:\n", + " x: Binary string as numpy array.\n", + " w: Adjacency matrix.\n", + " Returns:\n", + " Value of the cut.\n", + " \"\"\"\n", + " X = np.outer(x, (1 - x))\n", + " w_01 = np.where(w != 0, 1, 0)\n", + " return np.sum(w_01 * X)\n", + "\n", + "\n", + "def bitfield(n, L):\n", + " result = np.binary_repr(n, L)\n", + " return [int(digit) for digit in result] # [2:] to chop off the \"0b\" part\n", + "\n", + "\n", + "# use the brute-force way to generate the oracle\n", + "L = num_nodes\n", + "max = 2**L\n", + "sol = np.inf\n", + "for i in range(max):\n", + " cur = bitfield(i, L)\n", + "\n", + " how_many_nonzero = np.count_nonzero(cur)\n", + " if how_many_nonzero * 2 != L: # not balanced\n", + " continue\n", + "\n", + " cur_v = objective_value(np.array(cur), w)\n", + " if cur_v < sol:\n", + " sol = cur_v\n", + "\n", + "print(f\"Objective value computed by the brute-force method is {sol}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "118d6256-4e1f-4637-9a68-a35b610a9321", + "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.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}