From d568aadf0c24df0ae863b4f27218b317f4651300 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 16:39:13 +0100 Subject: [PATCH 01/13] remove code-duplication --- src/bia_bob/_bug_fixing.py | 1 - src/bia_bob/_document.py | 1 - src/bia_bob/_machinery.py | 24 ++++++++++++++++++++---- 3 files changed, 20 insertions(+), 6 deletions(-) diff --git a/src/bia_bob/_bug_fixing.py b/src/bia_bob/_bug_fixing.py index c7b6444..ea93645 100644 --- a/src/bia_bob/_bug_fixing.py +++ b/src/bia_bob/_bug_fixing.py @@ -31,7 +31,6 @@ def fix(line:str=None, cell:str=None): if Context.assistant is None: init_assistant() p = get_ipython() - Context.variables = p.user_ns code, text = generate_response_to_user(Context.assistant.model, prompt) diff --git a/src/bia_bob/_document.py b/src/bia_bob/_document.py index 9c8926d..ccc3999 100644 --- a/src/bia_bob/_document.py +++ b/src/bia_bob/_document.py @@ -33,7 +33,6 @@ def doc(line:str=None, cell:str=None): if Context.assistant is None: init_assistant() p = get_ipython() - Context.variables = p.user_ns code, text = generate_response_to_user(Context.assistant.model, prompt) diff --git a/src/bia_bob/_machinery.py b/src/bia_bob/_machinery.py index 4642159..4223200 100644 --- a/src/bia_bob/_machinery.py +++ b/src/bia_bob/_machinery.py @@ -50,9 +50,6 @@ def bob(line: str = None, cell: str = None): display("Please ask a question!") return - # set context variables - Context.variables = get_ipython().user_ns - # generate the response Context.assistant.generate_response_to_user(user_input) @@ -94,9 +91,28 @@ def generate_response_to_user(self, user_input: str): -def init_assistant(model="gpt-3.5-turbo", temperature=0, auto_execute:bool = False): +def init_assistant(model="gpt-3.5-turbo", temperature=0, auto_execute:bool = False, variables:dict=None): + """Initialises the assistant. + + Parameters + ---------- + model: str + temperature: float, optional (default: 0, between 0 and 1) The higher the temperature, the more random the output. + auto_execute: bool, optional (default: False) If True, the assistant will automatically execute the code it generates. + variables: dict, optional (default: None) A dictionary of variables that should be available to the assistant. + If None, it will use the global variables of the current namespace. + + """ + from IPython.core.getipython import get_ipython Context.assistant = CustomAgent(model, temperature) Context.auto_execute = auto_execute + + if variables is None: + p = get_ipython() + Context.variables = p.user_ns + else: + Context.variables = variables + if Context.verbose: print("Assistant initialised. You can now use it, e.g., copy and paste the" "below two lines into the next cell and execute it." From fcc61da5e1611320fc4368e9cd2ff5e936b3a0c3 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 16:47:58 +0100 Subject: [PATCH 02/13] remove temperature as discussed in #53 --- src/bia_bob/_machinery.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/bia_bob/_machinery.py b/src/bia_bob/_machinery.py index 4223200..96bb9c3 100644 --- a/src/bia_bob/_machinery.py +++ b/src/bia_bob/_machinery.py @@ -67,9 +67,8 @@ def combine_user_input(line, cell): class CustomAgent: - def __init__(self, model="gpt-3.5-turbo", temperature=0): + def __init__(self, model="gpt-3.5-turbo"): self.model = model - self.temperature = temperature def generate_response_to_user(self, user_input: str): """Sends a prompt to openAI @@ -91,20 +90,19 @@ def generate_response_to_user(self, user_input: str): -def init_assistant(model="gpt-3.5-turbo", temperature=0, auto_execute:bool = False, variables:dict=None): +def init_assistant(model="gpt-3.5-turbo", auto_execute:bool = False, variables:dict=None): """Initialises the assistant. Parameters ---------- model: str - temperature: float, optional (default: 0, between 0 and 1) The higher the temperature, the more random the output. auto_execute: bool, optional (default: False) If True, the assistant will automatically execute the code it generates. variables: dict, optional (default: None) A dictionary of variables that should be available to the assistant. If None, it will use the global variables of the current namespace. """ from IPython.core.getipython import get_ipython - Context.assistant = CustomAgent(model, temperature) + Context.assistant = CustomAgent(model) Context.auto_execute = auto_execute if variables is None: From a5c1c37126f89aee718ae777da881790cf3f03e9 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 16:55:26 +0100 Subject: [PATCH 03/13] Removed the CustomAssistant class ... as it was kind of replicating the Context classes purpose --- src/bia_bob/_bug_fixing.py | 4 ++-- src/bia_bob/_document.py | 4 ++-- src/bia_bob/_machinery.py | 34 +++++++++++++++++----------------- 3 files changed, 21 insertions(+), 21 deletions(-) diff --git a/src/bia_bob/_bug_fixing.py b/src/bia_bob/_bug_fixing.py index ea93645..950bf3e 100644 --- a/src/bia_bob/_bug_fixing.py +++ b/src/bia_bob/_bug_fixing.py @@ -28,10 +28,10 @@ def fix(line:str=None, cell:str=None): Please correct the code. """ - if Context.assistant is None: + if Context.model is None: init_assistant() p = get_ipython() - code, text = generate_response_to_user(Context.assistant.model, prompt) + code, text = generate_response_to_user(Context.model, prompt) p.set_next_input(code, replace=True) diff --git a/src/bia_bob/_document.py b/src/bia_bob/_document.py index ccc3999..1e03870 100644 --- a/src/bia_bob/_document.py +++ b/src/bia_bob/_document.py @@ -30,11 +30,11 @@ def doc(line:str=None, cell:str=None): ``` """ - if Context.assistant is None: + if Context.model is None: init_assistant() p = get_ipython() - code, text = generate_response_to_user(Context.assistant.model, prompt) + code, text = generate_response_to_user(Context.model, prompt) p.set_next_input(code, replace=True) diff --git a/src/bia_bob/_machinery.py b/src/bia_bob/_machinery.py index 96bb9c3..6b07e06 100644 --- a/src/bia_bob/_machinery.py +++ b/src/bia_bob/_machinery.py @@ -6,8 +6,8 @@ class Context: - assistant = None variables = None + model = None verbose = False auto_execute = False chat = [] @@ -42,7 +42,7 @@ def bob(line: str = None, cell: str = None): and pastes the code into the next cell. """ - if Context.assistant is None: + if Context.model is None: init_assistant() user_input = combine_user_input(line, cell) @@ -51,7 +51,18 @@ def bob(line: str = None, cell: str = None): return # generate the response - Context.assistant.generate_response_to_user(user_input) + code, text = generate_response_to_user(Context.model, user_input) + + if code is None or not Context.auto_execute: + output_text(text) + + if code is not None: + p = get_ipython() + if Context.auto_execute: + p.set_next_input(code, replace=True) + p.run_cell(code) + else: + p.set_next_input(code, replace=False) def combine_user_input(line, cell): @@ -70,23 +81,12 @@ class CustomAgent: def __init__(self, model="gpt-3.5-turbo"): self.model = model - def generate_response_to_user(self, user_input: str): + def respond_to_user(self, user_input: str): """Sends a prompt to openAI and shows the text response and pastes the code into the next cell. """ - code, text = generate_response_to_user(self.model, user_input) - - if code is None or not Context.auto_execute: - output_text(text) - - if code is not None: - p = get_ipython() - if Context.auto_execute: - p.set_next_input(code, replace=True) - p.run_cell(code) - else: - p.set_next_input(code, replace=False) + @@ -102,7 +102,7 @@ def init_assistant(model="gpt-3.5-turbo", auto_execute:bool = False, variables:d """ from IPython.core.getipython import get_ipython - Context.assistant = CustomAgent(model) + Context.model = model Context.auto_execute = auto_execute if variables is None: From 89fe2815185bf8fbc7c18d9cbfd4a5abef2fab38 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 16:57:26 +0100 Subject: [PATCH 04/13] reran notebook --- demo/analysis_workflow.ipynb | 214 ++++++++++++++++++++++++++--------- src/bia_bob/__init__.py | 2 +- 2 files changed, 161 insertions(+), 55 deletions(-) diff --git a/demo/analysis_workflow.ipynb b/demo/analysis_workflow.ipynb index 42dda38..23206cc 100644 --- a/demo/analysis_workflow.ipynb +++ b/demo/analysis_workflow.ipynb @@ -20,7 +20,7 @@ { "data": { "text/plain": [ - "'0.3.1'" + "'0.4.0'" ] }, "execution_count": 2, @@ -59,7 +59,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "4b4ac42c-3124-4b25-8930-5f893ca291e8", + "id": "9b590a62-0dbc-4866-909e-ef353349bfb7", "metadata": {}, "outputs": [ { @@ -102,10 +102,7 @@ "from skimage.io import imread\n", "import stackview\n", "\n", - "# Load the image\n", "image = imread(\"blobs.tif\")\n", - "\n", - "# Display the image\n", "stackview.insight(image)" ] }, @@ -118,7 +115,7 @@ { "data": { "text/markdown": [ - "To segment the image stored in the `image` variable using thresholding and connected component labeling, and to show the resulting label image, you can use the following code:" + "To segment the image stored in the variable `image`, we can use thresholding followed by connected component labeling. Here's the code to accomplish this:" ], "text/plain": [ "" @@ -138,13 +135,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "53739416-bb77-4ee9-95e2-b219fe582618", + "id": "ed57444f-1030-4803-bcb0-2cfb13db420b", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "edeecc98783d49a79bf185afd69b8deb", + "model_id": "7039b8385e324a18a2510e1f51f8a4c5", "version_major": 2, "version_minor": 0 }, @@ -162,15 +159,15 @@ "from skimage.measure import label\n", "import stackview\n", "\n", - "# Threshold the image\n", - "threshold = threshold_otsu(image)\n", - "binary_image = image > threshold\n", + "# Thresholding\n", + "threshold_value = threshold_otsu(image)\n", + "binary_image = image > threshold_value\n", "\n", - "# Label the connected components\n", - "labels = label(binary_image)\n", + "# Connected component labeling\n", + "label_image = label(binary_image)\n", "\n", "# Display the label image\n", - "stackview.curtain(image, labels)" + "stackview.curtain(image, label_image)" ] }, { @@ -182,7 +179,7 @@ { "data": { "text/markdown": [ - "To measure the size and shape of the segmented objects and store the results in a Pandas DataFrame, you can use the following code:" + "To measure the size and shape of the segmented objects and store the results in a Pandas dataframe, you can use the `regionprops` function from the `skimage.measure` module. Here's the code to accomplish this:" ], "text/plain": [ "" @@ -202,28 +199,139 @@ { "cell_type": "code", "execution_count": 8, - "id": "656e41a8-a810-43da-bf98-800bed552f47", + "id": "feaa76fa-3b55-4c0f-b76a-3677f075226e", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - " Label Area Perimeter Eccentricity\n", - "0 1 433 91.254834 0.876649\n", - "1 2 185 53.556349 0.828189\n", - "2 3 658 95.698485 0.352060\n", - "3 4 434 76.870058 0.341084\n", - "4 5 477 83.798990 0.771328\n", - ".. ... ... ... ...\n", - "59 60 1 0.000000 0.000000\n", - "60 61 81 40.727922 0.947745\n", - "61 62 90 46.278175 0.971003\n", - "62 63 53 31.899495 0.939695\n", - "63 64 49 34.485281 0.974495\n", - "\n", - "[64 rows x 4 columns]\n" - ] + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
areacentroideccentricityperimeter
0433(13.212471131639722, 19.986143187066975)0.87664991.254834
1185(4.27027027027027, 62.945945945945944)0.82818953.556349
2658(12.56838905775076, 108.32978723404256)0.35206095.698485
3434(9.806451612903226, 154.52073732718895)0.34108476.870058
4477(13.545073375262055, 246.8092243186583)0.77132883.798990
...............
591(246.0, 110.0)0.0000000.000000
6081(251.1358024691358, 178.74074074074073)0.94774540.727922
6190(251.32222222222222, 127.6)0.97100346.278175
6253(251.56603773584905, 234.39622641509433)0.93969531.899495
6349(251.91836734693877, 73.79591836734694)0.97449534.485281
\n", + "

64 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " area centroid eccentricity perimeter\n", + "0 433 (13.212471131639722, 19.986143187066975) 0.876649 91.254834\n", + "1 185 (4.27027027027027, 62.945945945945944) 0.828189 53.556349\n", + "2 658 (12.56838905775076, 108.32978723404256) 0.352060 95.698485\n", + "3 434 (9.806451612903226, 154.52073732718895) 0.341084 76.870058\n", + "4 477 (13.545073375262055, 246.8092243186583) 0.771328 83.798990\n", + ".. ... ... ... ...\n", + "59 1 (246.0, 110.0) 0.000000 0.000000\n", + "60 81 (251.1358024691358, 178.74074074074073) 0.947745 40.727922\n", + "61 90 (251.32222222222222, 127.6) 0.971003 46.278175\n", + "62 53 (251.56603773584905, 234.39622641509433) 0.939695 31.899495\n", + "63 49 (251.91836734693877, 73.79591836734694) 0.974495 34.485281\n", + "\n", + "[64 rows x 4 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -231,22 +339,15 @@ "from skimage.measure import regionprops\n", "\n", "# Measure size and shape of segmented objects\n", - "props = regionprops(labels)\n", - "\n", - "# Create a Pandas DataFrame to store the results\n", - "data = {'Label': [], 'Area': [], 'Perimeter': [], 'Eccentricity': []}\n", + "properties = ['area', 'centroid', 'eccentricity', 'perimeter']\n", + "objects = regionprops(label_image, intensity_image=image, cache=True)\n", + "data = [[getattr(obj, prop) for prop in properties] for obj in objects]\n", "\n", - "# Populate the DataFrame with measurements\n", - "for prop in props:\n", - " data['Label'].append(prop.label)\n", - " data['Area'].append(prop.area)\n", - " data['Perimeter'].append(prop.perimeter)\n", - " data['Eccentricity'].append(prop.eccentricity)\n", + "# Create dataframe\n", + "df = pd.DataFrame(data, columns=properties)\n", "\n", - "df = pd.DataFrame(data)\n", - "\n", - "# Display the DataFrame\n", - "print(df)" + "# Show the dataframe\n", + "df" ] }, { @@ -258,7 +359,7 @@ { "data": { "text/markdown": [ - "To plot the perimeter against eccentricity using the Seaborn library, you can use the following code:" + "To plot the perimeter against eccentricity using the seaborn library, you can use the `scatterplot` function from the `seaborn` module. Here's the code to accomplish this:" ], "text/plain": [ "" @@ -276,12 +377,12 @@ { "cell_type": "code", "execution_count": 10, - "id": "60851234-6838-452e-b6f4-935162a0d9ac", + "id": "16e29db7-174f-4819-bab6-6398441ce4e7", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -292,12 +393,17 @@ ], "source": [ "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", "\n", - "# Plot the data\n", - "sns.scatterplot(data=df, x='Perimeter', y='Eccentricity')\n", + "# Plotting the data\n", + "sns.scatterplot(data=df, x='perimeter', y='eccentricity')\n", + "\n", + "# Add axis labels and title\n", + "plt.xlabel('Perimeter')\n", + "plt.ylabel('Eccentricity')\n", + "plt.title('Perimeter vs Eccentricity')\n", "\n", "# Show the plot\n", - "import matplotlib.pyplot as plt\n", "plt.show()" ] }, diff --git a/src/bia_bob/__init__.py b/src/bia_bob/__init__.py index 58f442a..da5253d 100644 --- a/src/bia_bob/__init__.py +++ b/src/bia_bob/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.3.0" +__version__ = "0.4.0" __all__ = ( ) From 028f01c5fccab6330ce66c517ebe4d85f6303c50 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 17:01:15 +0100 Subject: [PATCH 05/13] better comments and docstrings --- src/bia_bob/_bug_fixing.py | 7 ++++++- src/bia_bob/_document.py | 9 --------- src/bia_bob/_machinery.py | 4 ++++ 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/bia_bob/_bug_fixing.py b/src/bia_bob/_bug_fixing.py index 950bf3e..a55967b 100644 --- a/src/bia_bob/_bug_fixing.py +++ b/src/bia_bob/_bug_fixing.py @@ -1,17 +1,22 @@ from IPython.core.magic import register_line_cell_magic @register_line_cell_magic -def fix(line:str=None, cell:str=None): +def fix(line: str = None, cell: str = None): + """This Jupyter Magic automatically fixes code when it's in the first line of a cell that caused an error that just + happened. + """ from IPython.core.getipython import get_ipython from ._machinery import bob, combine_user_input, Context, init_assistant from ._utilities import generate_response_to_user ip = get_ipython() if cell is None and line is None: + # if the function was called as fix(), it will use the last executed cell instead of the magic-marked cell variables = get_ipython().user_ns code = variables['_i'] else: code = combine_user_input(line, cell) + # this reads the last error that occurred error = ip.get_exception_only() prompt = f""" diff --git a/src/bia_bob/_document.py b/src/bia_bob/_document.py index 1e03870..bd10b36 100644 --- a/src/bia_bob/_document.py +++ b/src/bia_bob/_document.py @@ -4,15 +4,6 @@ def doc(line:str=None, cell:str=None): """ This Jupyter Magic automatically documents code when it's in the first line of a cell. - - Usage: - ``` - import bia_bob - ``` - ``` - %%document - ... code you would like do document better - ``` """ from ._machinery import Context, init_assistant, combine_user_input from ._utilities import generate_response_to_user diff --git a/src/bia_bob/_machinery.py b/src/bia_bob/_machinery.py index 6b07e06..0ae04e6 100644 --- a/src/bia_bob/_machinery.py +++ b/src/bia_bob/_machinery.py @@ -53,15 +53,19 @@ def bob(line: str = None, cell: str = None): # generate the response code, text = generate_response_to_user(Context.model, user_input) + # print out explanation if code is None or not Context.auto_execute: output_text(text) if code is not None: p = get_ipython() if Context.auto_execute: + # replace the current cell that contained the prompt p.set_next_input(code, replace=True) + # execute it p.run_cell(code) else: + # put a new cell below the current cell p.set_next_input(code, replace=False) From 5ab63ccf54633d23872c29ec735289f5e8de61e6 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 17:01:33 +0100 Subject: [PATCH 06/13] removed unused function --- src/bia_bob/_utilities.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/bia_bob/_utilities.py b/src/bia_bob/_utilities.py index 7a781e1..f8df7e5 100644 --- a/src/bia_bob/_utilities.py +++ b/src/bia_bob/_utilities.py @@ -108,13 +108,6 @@ def print_chat(chat): print(content) -def concatenate_chat_content(chat): - concatenated_chat = "" - for message in chat: - concatenated_chat += message['content'] - return concatenated_chat - - def output_text(text): """Display markdown content in the notebook.""" if is_notebook(): From 14fcdadcc4f7ab42c19732d947f4cce999128bd8 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 17:10:40 +0100 Subject: [PATCH 07/13] return available model names instead of printing them --- demo/choose_model.ipynb | 177 ++++++++++++++++++++++---------------- src/bia_bob/_utilities.py | 3 +- 2 files changed, 102 insertions(+), 78 deletions(-) diff --git a/demo/choose_model.ipynb b/demo/choose_model.ipynb index 73ec578..16f22c2 100644 --- a/demo/choose_model.ipynb +++ b/demo/choose_model.ipynb @@ -26,73 +26,83 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "text-search-babbage-doc-001\n", - "curie-search-query\n", - "text-search-babbage-query-001\n", - "babbage\n", - "babbage-search-query\n", - "text-babbage-001\n", - "text-similarity-davinci-001\n", - "davinci\n", - "davinci-similarity\n", - "code-davinci-edit-001\n", - "curie-similarity\n", - "babbage-search-document\n", - "curie-instruct-beta\n", - "text-search-ada-doc-001\n", - "davinci-instruct-beta\n", - "text-similarity-babbage-001\n", - "text-search-davinci-doc-001\n", - "babbage-similarity\n", - "davinci-search-query\n", - "text-similarity-curie-001\n", - "text-davinci-001\n", - "text-search-davinci-query-001\n", - "ada-search-document\n", - "ada-code-search-code\n", - "babbage-002\n", - "davinci-002\n", - "davinci-search-document\n", - "curie-search-document\n", - "babbage-code-search-code\n", - "text-search-ada-query-001\n", - "whisper-1\n", - "code-search-ada-text-001\n", - "babbage-code-search-text\n", - "code-search-babbage-code-001\n", - "ada-search-query\n", - "ada-code-search-text\n", - "text-search-curie-query-001\n", - "text-davinci-002\n", - "text-embedding-ada-002\n", - "text-davinci-edit-001\n", - "code-search-babbage-text-001\n", - "gpt-3.5-turbo-instruct-0914\n", - "ada\n", - "text-ada-001\n", - "ada-similarity\n", - "code-search-ada-code-001\n", - "text-similarity-ada-001\n", - "gpt-3.5-turbo-0301\n", - "gpt-3.5-turbo-instruct\n", - "gpt-3.5-turbo-16k\n", - "text-search-curie-doc-001\n", - "gpt-4-0613\n", - "gpt-3.5-turbo-16k-0613\n", - "text-davinci-003\n", - "gpt-4\n", - "text-curie-001\n", - "curie\n", - "gpt-3.5-turbo-0613\n", - "gpt-4-0314\n", - "gpt-3.5-turbo\n", - "ft:gpt-3.5-turbo-0613:personal::7zVLxA5b\n", - "ft:gpt-3.5-turbo-0613:personal::7zUyeEKY\n", - "ft:gpt-3.5-turbo-0613:personal::7zUen5wo\n" - ] + "data": { + "text/plain": [ + "['text-search-babbage-doc-001',\n", + " 'gpt-3.5-turbo-16k-0613',\n", + " 'curie-search-query',\n", + " 'gpt-3.5-turbo-16k',\n", + " 'text-search-babbage-query-001',\n", + " 'babbage',\n", + " 'babbage-search-query',\n", + " 'text-babbage-001',\n", + " 'whisper-1',\n", + " 'text-similarity-davinci-001',\n", + " 'davinci-similarity',\n", + " 'code-davinci-edit-001',\n", + " 'curie-similarity',\n", + " 'babbage-search-document',\n", + " 'curie-instruct-beta',\n", + " 'text-search-ada-doc-001',\n", + " 'davinci-instruct-beta',\n", + " 'gpt-3.5-turbo-0613',\n", + " 'text-similarity-babbage-001',\n", + " 'text-search-davinci-doc-001',\n", + " 'gpt-4-0314',\n", + " 'gpt-4-0613',\n", + " 'gpt-4',\n", + " 'babbage-similarity',\n", + " 'text-embedding-ada-002',\n", + " 'davinci-search-query',\n", + " 'text-similarity-curie-001',\n", + " 'text-davinci-001',\n", + " 'text-search-davinci-query-001',\n", + " 'ada-search-document',\n", + " 'ada-code-search-code',\n", + " 'babbage-002',\n", + " 'davinci-002',\n", + " 'davinci-search-document',\n", + " 'curie-search-document',\n", + " 'babbage-code-search-code',\n", + " 'text-search-ada-query-001',\n", + " 'code-search-ada-text-001',\n", + " 'babbage-code-search-text',\n", + " 'code-search-babbage-code-001',\n", + " 'ada-search-query',\n", + " 'ada-code-search-text',\n", + " 'text-search-curie-query-001',\n", + " 'text-davinci-002',\n", + " 'text-davinci-edit-001',\n", + " 'code-search-babbage-text-001',\n", + " 'gpt-3.5-turbo',\n", + " 'gpt-3.5-turbo-instruct-0914',\n", + " 'ada',\n", + " 'text-ada-001',\n", + " 'ada-similarity',\n", + " 'code-search-ada-code-001',\n", + " 'text-similarity-ada-001',\n", + " 'gpt-3.5-turbo-0301',\n", + " 'gpt-3.5-turbo-instruct',\n", + " 'text-search-curie-doc-001',\n", + " 'text-davinci-003',\n", + " 'text-curie-001',\n", + " 'curie',\n", + " 'davinci',\n", + " 'ft:gpt-3.5-turbo-0613:personal::7zUyeEKY',\n", + " 'ft:gpt-3.5-turbo-0613:personal::7zVLxA5b',\n", + " 'ft:gpt-3.5-turbo-0613:personal::8F1Bh4nk',\n", + " 'ft:gpt-3.5-turbo-0613:personal::8EyMmUpY',\n", + " 'ft:gpt-3.5-turbo-0613:personal::8ExMgIyE',\n", + " 'ft:gpt-3.5-turbo-0613:personal::8F51T395',\n", + " 'ft:gpt-3.5-turbo-0613:personal::7zUen5wo',\n", + " 'ft:gpt-3.5-turbo-0613:personal::8ExLLbYX',\n", + " 'ft:gpt-3.5-turbo-0613:personal::8EwxBNGh',\n", + " 'ft:gpt-3.5-turbo-0613:personal::8Exw7Ggs']" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -126,7 +136,9 @@ "outputs": [ { "data": { - "text/markdown": [], + "text/markdown": [ + "First, we are going to import the necessary library. Then, we use that library's function called imread to read the image file named 'blobs.tif' from the disc. We store the image data in a variable named 'input_image'. Finally, we use the stackview.insight function from the stackview library to display the image we just read and stored." + ], "text/plain": [ "" ] @@ -142,10 +154,8 @@ { "cell_type": "code", "execution_count": 5, - "id": "87ec6f70-977f-4da1-a4bf-5b004bbea409", - "metadata": { - "scrolled": true - }, + "id": "4a6946bd-904f-4a0c-8e2a-c83508648fd9", + "metadata": {}, "outputs": [ { "data": { @@ -187,10 +197,7 @@ "from skimage.io import imread\n", "import stackview\n", "\n", - "#load the image\n", "input_image = imread('blobs.tif')\n", - "\n", - "# Display the image\n", "stackview.insight(input_image)" ] }, @@ -202,7 +209,13 @@ "outputs": [ { "data": { - "text/markdown": [], + "text/markdown": [ + "Voronoi Otsu labeling is a powerful technique for segmentation of cell images. This process involves two major steps. \n", + "\n", + "The first step, Voronoi diagram computation, will delineate cells based on their intensity contrast in the original image. The second step, applying Otsu's thresholding, will convert the intensity-based Voronoi diagram into a binary image where foreground represents cells and the background being the non-cellular space. Finally, the function skimage.measure.label is used to assign each connected component of the binary image a unique identifier or label. \n", + "\n", + "In this task, we'll use the pyclesperanto-prototype library to apply thevoronoi_otsu_labeling function directly to the `input_image`." + ], "text/plain": [ "" ] @@ -215,6 +228,18 @@ "%bob apply voronoi-otsu-labeling directly to the `input_image`." ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf15ea2c-1fcc-484b-84cf-4945fcb01b09", + "metadata": {}, + "outputs": [], + "source": [ + "import pyclesperanto_prototype as cle\n", + "\n", + "labels = cle.voronoi_otsu_labeling(input_image, spot_sigma=2, outline_sigma=1)" + ] + }, { "cell_type": "code", "execution_count": 7, diff --git a/src/bia_bob/_utilities.py b/src/bia_bob/_utilities.py index f8df7e5..9383463 100644 --- a/src/bia_bob/_utilities.py +++ b/src/bia_bob/_utilities.py @@ -157,8 +157,7 @@ def generate_response_from_openai(model: str, system_prompt: str, user_prompt: s def available_models(): import openai models = openai.Model.list() - for model in models['data']: - print(model['id']) + return [model['id'] for model in models['data']] def keep_available_packages(libraries): From dfb47898c9f5ce1d23d556172fe39807fc5ae7a8 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 17:12:45 +0100 Subject: [PATCH 08/13] docstrings and comments --- src/bia_bob/_utilities.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/bia_bob/_utilities.py b/src/bia_bob/_utilities.py index 9383463..b786f00 100644 --- a/src/bia_bob/_utilities.py +++ b/src/bia_bob/_utilities.py @@ -36,10 +36,13 @@ def generate_response_to_user(model, user_prompt: str): def create_system_prompt(): + """Creates a system prompt that contains instructions of general interest, available functions and variables.""" # determine useful variables and functions in context variables = [] functions = [] from ._machinery import Context + + # figure out which variables are not private for key, value in Context.variables.items(): if key.startswith("_"): continue @@ -48,7 +51,9 @@ def create_system_prompt(): functions.append(key) continue variables.append(key) + libraries = Context.libraries + system_prompt = f""" If the request entails writing code, write concise professional bioimage analysis high-quality python code. The code should be as short as possible. @@ -118,6 +123,7 @@ def output_text(text): def is_notebook() -> bool: + """Returns true if the code is currently executed in a Jupyter notebook.""" # adapted from: https://stackoverflow.com/questions/15411967/how-can-i-check-if-code-is-executed-in-the-ipython-notebook from IPython.core.getipython import get_ipython @@ -155,6 +161,7 @@ def generate_response_from_openai(model: str, system_prompt: str, user_prompt: s def available_models(): + """Returns a list of available model names in openAI.""" import openai models = openai.Model.list() return [model['id'] for model in models['data']] From e6fe24db30127c479576b52f62a8f03765666078 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 17:17:27 +0100 Subject: [PATCH 09/13] add comments and variable names --- demo/analysis_workflow.ipynb | 206 ++++++++--------------------------- src/bia_bob/_machinery.py | 2 - src/bia_bob/_utilities.py | 15 ++- 3 files changed, 56 insertions(+), 167 deletions(-) diff --git a/demo/analysis_workflow.ipynb b/demo/analysis_workflow.ipynb index 23206cc..d1529f4 100644 --- a/demo/analysis_workflow.ipynb +++ b/demo/analysis_workflow.ipynb @@ -42,7 +42,7 @@ { "data": { "text/markdown": [ - "To load the \"blobs.tif\" image file and display it, you can use the following code:" + "To load the `blobs.tif` image and display it, you can use the following code:" ], "text/plain": [ "" @@ -59,7 +59,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "9b590a62-0dbc-4866-909e-ef353349bfb7", + "id": "fa3e15f6-272b-4583-b07f-d213fc0d76b8", "metadata": {}, "outputs": [ { @@ -102,7 +102,10 @@ "from skimage.io import imread\n", "import stackview\n", "\n", - "image = imread(\"blobs.tif\")\n", + "# Load the image\n", + "image = imread('blobs.tif')\n", + "\n", + "# Display the image\n", "stackview.insight(image)" ] }, @@ -115,7 +118,7 @@ { "data": { "text/markdown": [ - "To segment the image stored in the variable `image`, we can use thresholding followed by connected component labeling. Here's the code to accomplish this:" + "To segment the image stored in the variable `image` using thresholding and connected component labeling, you can use the following code:" ], "text/plain": [ "" @@ -135,13 +138,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "ed57444f-1030-4803-bcb0-2cfb13db420b", + "id": "fc234779-cf32-4410-b475-73c10cb53460", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7039b8385e324a18a2510e1f51f8a4c5", + "model_id": "316abfc1846540e3b1960252f37a9ddf", "version_major": 2, "version_minor": 0 }, @@ -155,19 +158,18 @@ } ], "source": [ - "from skimage.filters import threshold_otsu\n", - "from skimage.measure import label\n", + "from skimage import filters, measure\n", "import stackview\n", "\n", - "# Thresholding\n", - "threshold_value = threshold_otsu(image)\n", + "# Threshold the image using Otsu's method\n", + "threshold_value = filters.threshold_otsu(image)\n", "binary_image = image > threshold_value\n", "\n", - "# Connected component labeling\n", - "label_image = label(binary_image)\n", + "# Perform connected component labeling\n", + "labels = measure.label(binary_image)\n", "\n", "# Display the label image\n", - "stackview.curtain(image, label_image)" + "stackview.curtain(image, labels)" ] }, { @@ -179,7 +181,7 @@ { "data": { "text/markdown": [ - "To measure the size and shape of the segmented objects and store the results in a Pandas dataframe, you can use the `regionprops` function from the `skimage.measure` module. Here's the code to accomplish this:" + "To measure the size and shape of the segmented objects and store the results in a Pandas dataframe, you can use the following code:" ], "text/plain": [ "" @@ -199,155 +201,42 @@ { "cell_type": "code", "execution_count": 8, - "id": "feaa76fa-3b55-4c0f-b76a-3677f075226e", + "id": "ccdc9bc3-0976-4fc9-a8fd-4f9562c8cd72", "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
areacentroideccentricityperimeter
0433(13.212471131639722, 19.986143187066975)0.87664991.254834
1185(4.27027027027027, 62.945945945945944)0.82818953.556349
2658(12.56838905775076, 108.32978723404256)0.35206095.698485
3434(9.806451612903226, 154.52073732718895)0.34108476.870058
4477(13.545073375262055, 246.8092243186583)0.77132883.798990
...............
591(246.0, 110.0)0.0000000.000000
6081(251.1358024691358, 178.74074074074073)0.94774540.727922
6190(251.32222222222222, 127.6)0.97100346.278175
6253(251.56603773584905, 234.39622641509433)0.93969531.899495
6349(251.91836734693877, 73.79591836734694)0.97449534.485281
\n", - "

64 rows × 4 columns

\n", - "
" - ], - "text/plain": [ - " area centroid eccentricity perimeter\n", - "0 433 (13.212471131639722, 19.986143187066975) 0.876649 91.254834\n", - "1 185 (4.27027027027027, 62.945945945945944) 0.828189 53.556349\n", - "2 658 (12.56838905775076, 108.32978723404256) 0.352060 95.698485\n", - "3 434 (9.806451612903226, 154.52073732718895) 0.341084 76.870058\n", - "4 477 (13.545073375262055, 246.8092243186583) 0.771328 83.798990\n", - ".. ... ... ... ...\n", - "59 1 (246.0, 110.0) 0.000000 0.000000\n", - "60 81 (251.1358024691358, 178.74074074074073) 0.947745 40.727922\n", - "61 90 (251.32222222222222, 127.6) 0.971003 46.278175\n", - "62 53 (251.56603773584905, 234.39622641509433) 0.939695 31.899495\n", - "63 49 (251.91836734693877, 73.79591836734694) 0.974495 34.485281\n", - "\n", - "[64 rows x 4 columns]" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + " label area perimeter eccentricity extent\n", + "0 1 433 91.254834 0.876649 0.555128\n", + "1 2 185 53.556349 0.828189 0.800866\n", + "2 3 658 95.698485 0.352060 0.870370\n", + "3 4 434 76.870058 0.341084 0.820416\n", + "4 5 477 83.798990 0.771328 0.865699\n", + ".. ... ... ... ... ...\n", + "59 60 1 0.000000 0.000000 1.000000\n", + "60 61 81 40.727922 0.947745 0.710526\n", + "61 62 90 46.278175 0.971003 0.782609\n", + "62 63 53 31.899495 0.939695 0.662500\n", + "63 64 49 34.485281 0.974495 0.720588\n", + "\n", + "[64 rows x 5 columns]\n" + ] } ], "source": [ "import pandas as pd\n", - "from skimage.measure import regionprops\n", + "from skimage import measure\n", "\n", - "# Measure size and shape of segmented objects\n", - "properties = ['area', 'centroid', 'eccentricity', 'perimeter']\n", - "objects = regionprops(label_image, intensity_image=image, cache=True)\n", - "data = [[getattr(obj, prop) for prop in properties] for obj in objects]\n", + "# Measure region properties of the labeled image\n", + "props = measure.regionprops_table(labels, properties=['label', 'area', 'perimeter', 'eccentricity', 'extent'])\n", "\n", - "# Create dataframe\n", - "df = pd.DataFrame(data, columns=properties)\n", + "# Convert the measured properties to a pandas dataframe\n", + "df = pd.DataFrame(props)\n", "\n", - "# Show the dataframe\n", - "df" + "# Display the dataframe\n", + "print(df)" ] }, { @@ -359,7 +248,7 @@ { "data": { "text/markdown": [ - "To plot the perimeter against eccentricity using the seaborn library, you can use the `scatterplot` function from the `seaborn` module. Here's the code to accomplish this:" + "To plot the perimeter against eccentricity using the seaborn library, you can use the following code:" ], "text/plain": [ "" @@ -377,12 +266,12 @@ { "cell_type": "code", "execution_count": 10, - "id": "16e29db7-174f-4819-bab6-6398441ce4e7", + "id": "9b82d119-965f-45da-a04d-6d63ec2df10d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -395,13 +284,12 @@ "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "\n", - "# Plotting the data\n", + "# Create a scatter plot using seaborn\n", "sns.scatterplot(data=df, x='perimeter', y='eccentricity')\n", "\n", - "# Add axis labels and title\n", + "# Set the axis labels\n", "plt.xlabel('Perimeter')\n", "plt.ylabel('Eccentricity')\n", - "plt.title('Perimeter vs Eccentricity')\n", "\n", "# Show the plot\n", "plt.show()" diff --git a/src/bia_bob/_machinery.py b/src/bia_bob/_machinery.py index 0ae04e6..b849c66 100644 --- a/src/bia_bob/_machinery.py +++ b/src/bia_bob/_machinery.py @@ -91,8 +91,6 @@ def respond_to_user(self, user_input: str): and pastes the code into the next cell. """ - - def init_assistant(model="gpt-3.5-turbo", auto_execute:bool = False, variables:dict=None): """Initialises the assistant. diff --git a/src/bia_bob/_utilities.py b/src/bia_bob/_utilities.py index b786f00..6c48a51 100644 --- a/src/bia_bob/_utilities.py +++ b/src/bia_bob/_utilities.py @@ -144,18 +144,21 @@ def generate_response_from_openai(model: str, system_prompt: str, user_prompt: s and returns only the text response. """ import openai + from ._machinery import Context - system = [{"role": "system", "content": system_prompt}] - user = [{"role": "user", "content": user_prompt}] + # assemple prompt + system_message = [{"role": "system", "content": system_prompt}] + user_message = [{"role": "user", "content": user_prompt}] + # retrieve answer response = openai.ChatCompletion.create( - messages=system + chat_history + user, + messages=system_message + chat_history + user_message, model=model) # stream=True would be nice - reply = response['choices'][0]['message']['content'] - from ._machinery import Context - Context.chat += user + [{"role": "assistant", "content": reply}] + # store question and answer in chat history + assistant_message = [{"role": "assistant", "content": reply}] + Context.chat += user_message + assistant_message return reply From 14866e40842db5775a5a451fb25f092c10cf239a Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 17:20:08 +0100 Subject: [PATCH 10/13] delayed imports, code style --- src/bia_bob/_bug_fixing.py | 2 ++ src/bia_bob/_document.py | 3 ++- src/bia_bob/_machinery.py | 8 ++++---- src/bia_bob/_utilities.py | 2 +- 4 files changed, 9 insertions(+), 6 deletions(-) diff --git a/src/bia_bob/_bug_fixing.py b/src/bia_bob/_bug_fixing.py index a55967b..cd346d7 100644 --- a/src/bia_bob/_bug_fixing.py +++ b/src/bia_bob/_bug_fixing.py @@ -1,4 +1,6 @@ from IPython.core.magic import register_line_cell_magic + + @register_line_cell_magic def fix(line: str = None, cell: str = None): """This Jupyter Magic automatically fixes code when it's in the first line of a cell that caused an error that just diff --git a/src/bia_bob/_document.py b/src/bia_bob/_document.py index bd10b36..cee111a 100644 --- a/src/bia_bob/_document.py +++ b/src/bia_bob/_document.py @@ -1,5 +1,6 @@ - from IPython.core.magic import register_line_cell_magic + + @register_line_cell_magic def doc(line:str=None, cell:str=None): """ diff --git a/src/bia_bob/_machinery.py b/src/bia_bob/_machinery.py index b849c66..b3fc19f 100644 --- a/src/bia_bob/_machinery.py +++ b/src/bia_bob/_machinery.py @@ -1,8 +1,5 @@ -from IPython.core.getipython import get_ipython from IPython.core.magic import register_line_cell_magic -from IPython.display import display - -from ._utilities import generate_response_to_user, output_text, keep_available_packages +from ._utilities import keep_available_packages class Context: @@ -41,6 +38,9 @@ def bob(line: str = None, cell: str = None): and shows the text and code response and pastes the code into the next cell. """ + from IPython.core.getipython import get_ipython + from IPython.display import display + from ._utilities import generate_response_to_user, output_text if Context.model is None: init_assistant() diff --git a/src/bia_bob/_utilities.py b/src/bia_bob/_utilities.py index 6c48a51..ea751fd 100644 --- a/src/bia_bob/_utilities.py +++ b/src/bia_bob/_utilities.py @@ -146,7 +146,7 @@ def generate_response_from_openai(model: str, system_prompt: str, user_prompt: s import openai from ._machinery import Context - # assemple prompt + # assemble prompt system_message = [{"role": "system", "content": system_prompt}] user_message = [{"role": "user", "content": user_prompt}] From f542ad052de0b004d07f129e04b237c36b021938 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 17:21:46 +0100 Subject: [PATCH 11/13] added documentation for developers --- README.md | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/README.md b/README.md index b4a34f1..556b9a1 100644 --- a/README.md +++ b/README.md @@ -64,10 +64,21 @@ mamba activate bt39 pip install bia-bob ``` +## Development + +If you want to contribute to `bia-bob`, you can install it in development mode like this: + +``` +git clone https://github.com/haesleinhuepf/bia-bob.git +cd bia-bob +pip install -e . +``` + ## Similar projects There are similar projects offering LLM-based support in Jupyter notebooks: * [jupyter-ai](https://github.com/jupyterlab/jupyter-ai) +* [napari-chatGPT](https://github.com/royerlab/napari-chatgpt) ## Issues From e18d60d6e888deb9b5d6792b5eb11b41579ba8c5 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 17:23:50 +0100 Subject: [PATCH 12/13] added documentation --- README.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 556b9a1..7c085af 100644 --- a/README.md +++ b/README.md @@ -6,14 +6,14 @@ BIA `bob` is a Jupyter-based assistant for interacting with data using generated ## Usage -You can initialize Bob like this: +You can initialize `bob` like this: ``` from bia_bob import bob ``` ### Code generation -Afterwards, you can ask Bob to generate code like this: +You can ask Bob to generate code like this: ``` %bob Load blobs.tif and show it ``` @@ -64,6 +64,8 @@ mamba activate bt39 pip install bia-bob ``` +Create an OpenAI API Key and add it to your environment variables as explained on [this page](https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety). + ## Development If you want to contribute to `bia-bob`, you can install it in development mode like this: @@ -82,7 +84,7 @@ There are similar projects offering LLM-based support in Jupyter notebooks: ## Issues -If you encounter any problems or want to provide feedback or suggestions, please create a thread on [image.sc](https://image.sc) along with a detailed description and tag [@haesleinhuepf]. +If you encounter any problems or want to provide feedback or suggestions, please create a thread on [image.sc](https://image.sc) along with a detailed description and tag @haesleinhuepf . From c01b53f9362c381317dc3ce5ec0b5ff1d785d9e1 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Tue, 31 Oct 2023 17:26:04 +0100 Subject: [PATCH 13/13] reran notebooks --- demo/basic_demo.ipynb | 57 +++++++------- demo/documenting_code.ipynb | 22 ++++-- demo/segment_blobs.ipynb | 149 ------------------------------------ demo/test_bob.ipynb | 13 +++- 4 files changed, 55 insertions(+), 186 deletions(-) delete mode 100644 demo/segment_blobs.ipynb diff --git a/demo/basic_demo.ipynb b/demo/basic_demo.ipynb index 448713b..fa61fc8 100644 --- a/demo/basic_demo.ipynb +++ b/demo/basic_demo.ipynb @@ -6,7 +6,7 @@ "metadata": {}, "source": [ "## BIA Bob demo\n", - "BIA Bob is a Jupyter-magic based assistant for interacting with data via code. " + "BIA Bob is a Jupyter-magic based assistant for interacting with data via code" ] }, { @@ -21,7 +21,7 @@ { "data": { "text/plain": [ - "'0.3.1'" + "'0.4.0'" ] }, "execution_count": 1, @@ -51,7 +51,7 @@ { "data": { "text/markdown": [ - "To load the \"blobs.tif\" image file and display it, you can use the following code:" + "To load the blobs.tif image file and display it, you can use the following code:" ], "text/plain": [ "" @@ -68,7 +68,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "37f7b36e-2278-405b-8af7-bb97f8281713", + "id": "fdd67ac9-d836-45fb-8d68-09051f75a98d", "metadata": {}, "outputs": [ { @@ -112,7 +112,7 @@ "import stackview\n", "\n", "# Load the image\n", - "image = imread(\"blobs.tif\")\n", + "image = imread('blobs.tif')\n", "\n", "# Display the image\n", "stackview.insight(image)" @@ -127,7 +127,7 @@ { "data": { "text/markdown": [ - "To perform the requested tasks on the \"blobs.tif\" image, including loading the image, segmenting the nuclei-like objects using Otsu's method and connected component labeling, measuring the area of the segmented labels, and printing the area on top of the labels, you can use the following code:" + "Here is the Python code that loads the blobs.tif grayscale image from disc, segments the nuclei-like objects using Otsu's method and connected component labeling, measures the area of the segmented labels, and prints the area on top of the labels:" ], "text/plain": [ "" @@ -149,50 +149,49 @@ { "cell_type": "code", "execution_count": 5, - "id": "30e97155-8314-4629-9d86-45ddc1078430", + "id": "f68a01b3-04eb-485c-a5b5-09eff7db44d2", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "4952503490f54e1188546f965c412472", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "
" + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=254, width=256),)),)), IntSlider(value=127, de…" ] }, + "execution_count": 5, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ "from skimage.io import imread\n", "from skimage.filters import threshold_otsu\n", "from skimage.measure import label, regionprops\n", - "import matplotlib.pyplot as plt\n", + "import stackview\n", "\n", - "# Load the image\n", - "image = imread(\"blobs.tif\")\n", + "# Load the blobs.tif grayscale image\n", + "image = imread('blobs.tif')\n", "\n", - "# Threshold using Otsu's method\n", - "threshold = threshold_otsu(image)\n", - "binary = image > threshold\n", + "# Apply Otsu's thresholding\n", + "thresh = threshold_otsu(image)\n", + "binary = image > thresh\n", "\n", "# Perform connected component labeling\n", "labels = label(binary)\n", "\n", - "# Measure area of the segmented labels\n", - "props = regionprops(labels)\n", - "areas = [prop.area for prop in props]\n", - "\n", - "# Display the image with area labels\n", - "fig, ax = plt.subplots(figsize=(10, 10))\n", - "ax.imshow(image, cmap='gray')\n", - "\n", - "for prop in props:\n", - " y, x = prop.centroid\n", - " area = prop.area\n", - " ax.text(x, y, f\"{area}\", color='red', ha='center', va='center', fontsize=8)\n", + "# Calculate and print the area of the segmented labels\n", + "for region in regionprops(labels):\n", + " area = region.area\n", + " centroid = region.centroid\n", + " labels[int(centroid[0]), int(centroid[1])] = f\"{area:.0f}\"\n", "\n", - "plt.show()" + "# Display the labels with area values\n", + "stackview.curtain(image, labels)" ] }, { diff --git a/demo/documenting_code.ipynb b/demo/documenting_code.ipynb index b38355f..a3a87e1 100644 --- a/demo/documenting_code.ipynb +++ b/demo/documenting_code.ipynb @@ -14,9 +14,21 @@ "execution_count": 1, "id": "6430b191-58af-4d84-b76e-39d7a9e1a38b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'0.4.0'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "from bia_bob import doc" + "from bia_bob import bob, doc\n", + "bob.__version__" ] }, { @@ -52,13 +64,13 @@ "from skimage.filters import threshold_otsu\n", "from skimage.measure import label\n", "\n", - "# Calculate the threshold value using Otsu algorithm\n", + "# Compute the threshold value using Otsu's method\n", "threshold = threshold_otsu(image)\n", "\n", - "# Create a binary image using the calculated threshold\n", + "# Create a binary image by thresholding the input image\n", "binary = image > threshold\n", "\n", - "# Label the connected components in the binary image\n", + "# Apply connected component labeling to the binary image\n", "labels = label(binary)" ] }, diff --git a/demo/segment_blobs.ipynb b/demo/segment_blobs.ipynb deleted file mode 100644 index 6d284cf..0000000 --- a/demo/segment_blobs.ipynb +++ /dev/null @@ -1,149 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "5ca09f65-d80a-489d-ac75-1c382bd4cef4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'0.3.0'" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from bia_bob import bob\n", - "bob.__version__" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "9b0d455c-e9b5-4705-9026-3d08abb488de", - "metadata": {}, - "outputs": [ - { - "data": { - "text/markdown": [ - "Sure! Here's a step-by-step plan for segmenting the nuclei in the \"blobs.tif\" grayscale image and displaying the resulting label mask:\n", - "\n", - "1. Load the \"blobs.tif\" image using the `imread` function from the scikit-image library.\n", - "2. Apply a thresholding method to the grayscale image to create a binary mask of the nuclei. You can use the `threshold_otsu` function from the scikit-image library to automatically determine the threshold value.\n", - "3. Use the binary mask to label the connected components of the nuclei using the `label` function from the scikit-image library.\n", - "4. Display the labeled mask using the `stackview.insight` function from the stackview library.\n", - "\n", - "And here's the code:" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%%bob \n", - "please segment all nuclei in the blobs.tif grayscale image \n", - "and show the resulting label mask (without the original image)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "4ac6b258-cec8-486d-9190-6b067c33e3cd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
shape(254, 256)
dtypeint32
size254.0 kB
min0
max64
\n", - "\n", - "
" - ], - "text/plain": [ - "StackViewNDArray([[0, 0, 0, ..., 5, 5, 5],\n", - " [0, 0, 0, ..., 5, 5, 5],\n", - " [0, 0, 0, ..., 5, 5, 5],\n", - " ...,\n", - " [0, 0, 0, ..., 0, 0, 0],\n", - " [0, 0, 0, ..., 0, 0, 0],\n", - " [0, 0, 0, ..., 0, 0, 0]])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from skimage.io import imread\n", - "from skimage.filters import threshold_otsu\n", - "from skimage.measure import label\n", - "import stackview\n", - "\n", - "# Load the grayscale image\n", - "image = imread(\"blobs.tif\")\n", - "\n", - "# Threshold the image to create a binary mask\n", - "threshold_value = threshold_otsu(image)\n", - "binary_mask = image > threshold_value\n", - "\n", - "# Label the connected components in the binary mask\n", - "labels = label(binary_mask)\n", - "\n", - "# Display the labeled mask\n", - "stackview.insight(labels)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8cdf85bc-f21e-4f69-adb6-415b4466626a", - "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.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/demo/test_bob.ipynb b/demo/test_bob.ipynb index 8925f74..a1c27d2 100644 --- a/demo/test_bob.ipynb +++ b/demo/test_bob.ipynb @@ -29,7 +29,11 @@ "outputs": [ { "data": { - "text/markdown": [], + "text/markdown": [ + "To load the image \"blobs.tif\" and display it, you can use the `imread` function from the `skimage.io` module to read the image file and the `stackview.insight` function to display the image.\n", + "\n", + "Here is the code:" + ], "text/plain": [ "" ] @@ -45,7 +49,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "39be3c6e-7d56-4a86-a81a-383060b53a1f", + "id": "431cb4e2-acd0-48d9-94d1-fd95328b56c6", "metadata": {}, "outputs": [ { @@ -88,7 +92,10 @@ "from skimage.io import imread\n", "import stackview\n", "\n", - "image = imread('blobs.tif')\n", + "# Load the image\n", + "image = imread(\"blobs.tif\")\n", + "\n", + "# Display the image\n", "stackview.insight(image)" ] },