From ba49c305ca5364fe8b6db2c2d15a9bf85c21ff7d Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Wed, 9 Aug 2023 16:31:56 +0200 Subject: [PATCH 1/6] add support for plotting columns in pandas DataFrames --- demo/pandas_plotting.ipynb | 137 +++++++++++++++++++++++++++++++++++++ setup.cfg | 2 + src/bia_bob/_tools.py | 21 ++++++ src/bia_bob/_utilities.py | 15 +++- 4 files changed, 174 insertions(+), 1 deletion(-) create mode 100644 demo/pandas_plotting.ipynb diff --git a/demo/pandas_plotting.ipynb b/demo/pandas_plotting.ipynb new file mode 100644 index 0000000..897c2e4 --- /dev/null +++ b/demo/pandas_plotting.ipynb @@ -0,0 +1,137 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f9661021-bfa6-485a-a735-2b5d06006063", + "metadata": {}, + "source": [ + "# Plotting\n", + "In this notebook we ask Bob to draw a plot from a given pandas Dataframe. It uses seaborn under the hood." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "31c311c0-5a8f-4bd5-a6ff-a63d151f9b21", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from bia_bob import bob" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b9805072-55f2-4ad0-af18-d4b4ac4e7f42", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6e590509-a159-4fa4-9ecf-1ad8ccb597ac", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "df = pd.DataFrame({\n", + " 'x':[1,2,3,4,5,6],\n", + " 'y':[1,1,2,2,3,4]\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e732fd57-73ec-4c34-85cc-fbd60bba4c32", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "bob.initialize(globals())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "359d68fc-112f-4a5a-859b-db19eb6aa04e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "Here is the plot of x against y in the dataframe df." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%bob Please draw a plot of x against y in the dataframe df." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c24112f8-afc6-40f3-af67-f5fd48ba758c", + "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/setup.cfg b/setup.cfg index cb4844d..09477aa 100644 --- a/setup.cfg +++ b/setup.cfg @@ -36,6 +36,8 @@ install_requires = langchain>=0.0.251 stackview>=0.6.3 napari-segment-blobs-and-things-with-membranes>=0.3.6 + pandas + seaborn python_requires = >=3.8 include_package_data = True diff --git a/src/bia_bob/_tools.py b/src/bia_bob/_tools.py index 0c28ecc..20b6d52 100644 --- a/src/bia_bob/_tools.py +++ b/src/bia_bob/_tools.py @@ -258,3 +258,24 @@ def multiply_image_with_factor(image_name: str, factor: int): +@_context.tools.append +@StructuredTool.from_function +def plot_columns_in_dataframe(dataframe, first_column, second_column): + """Plots columns in a dataframe""" + from ._utilities import find_dataframe + from IPython.core.display_functions import display + + if _context.verbose: + print("Plot command df:", dataframe) + print("Plot command 1st column:", first_column) + print("Plot command 2nd column:", second_column) + + df = find_dataframe(_context.variables, dataframe) + + import seaborn + display(seaborn.scatterplot(df, x=first_column, y=second_column)) + + return "The plot is shown." + + + diff --git a/src/bia_bob/_utilities.py b/src/bia_bob/_utilities.py index 029d8e3..1133739 100644 --- a/src/bia_bob/_utilities.py +++ b/src/bia_bob/_utilities.py @@ -28,6 +28,19 @@ def is_image(potential_image): def find_image(variables, key): + return find_variable(variables, key, is_image) + + +def is_dataframe(potential_dataframe): + import pandas as pd + return isinstance(potential_dataframe, pd.DataFrame) + + +def find_dataframe(variables, key): + return find_variable(variables, key, is_dataframe) + + +def find_variable(variables, key, type_checker_function): from ._machinery import _context if key in variables.keys(): return variables[key] @@ -36,7 +49,7 @@ def find_image(variables, key): if other_name in variables.keys(): return variables[other_name] - other_name = find_best_fit([v for v in variables.keys() if is_image(variables[v])], key) + other_name = find_best_fit([v for v in variables.keys() if type_checker_function(variables[v])], key) if _context.verbose: print("Searching for variable named ", other_name) return variables[other_name] \ No newline at end of file From 6727ad6bd3e1e9cef153adec810a617f1299cb73 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Wed, 9 Aug 2023 17:53:03 +0200 Subject: [PATCH 2/6] added more tools for working with pandas dataframes --- src/bia_bob/_tools.py | 93 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 90 insertions(+), 3 deletions(-) diff --git a/src/bia_bob/_tools.py b/src/bia_bob/_tools.py index 20b6d52..5f2b5c2 100644 --- a/src/bia_bob/_tools.py +++ b/src/bia_bob/_tools.py @@ -8,16 +8,30 @@ @_context.tools.append @tool def load_image(filename: str): - """Useful for loading and image file and storing it under a given variable name.""" + """Useful for loading an image file and storing it under a given variable name.""" from skimage.io import imread if _context.verbose: - print("loading", filename) + print("loading image", filename) image = imread(filename) _context.variables[make_variable_name(filename)] = image return "The image is now stored as " + filename +@_context.tools.append +@tool +def load_csv(filename: str): + """Useful for loading a csv file and storing its as pandas DataFrame under a given variable name.""" + from pandas import read_csv + + if _context.verbose: + print("loading csv", filename) + df = read_csv(filename) + _context.variables[make_variable_name(filename)] = df + return "The csv file is now stored as " + filename + + + @_context.tools.append @tool def image_size(filename: str): @@ -225,11 +239,34 @@ def orthogonal(image_name: str): @_context.tools.append @tool -def list_tools(text: str): +def list_tools(): """Lists all available tools""" return "\n".join(list([t.name for t in _context.tools])) + + +@_context.tools.append +@tool +def list_dataframes(): + """Lists all available dataframes""" + from ._utilities import is_dataframe + + return "\n".join(list([v for v in _context.variables.keys() if is_dataframe(_context.variables[v])])) + + +@_context.tools.append +@tool +def list_images(): + """Lists all available images""" + from ._utilities import is_image + + return "\n".join(list([v for v in _context.variables.keys() if is_image(_context.variables[v])])) + + + + + @_context.tools.append @tool def list_files_in_folder(folder: str): @@ -257,6 +294,56 @@ def multiply_image_with_factor(image_name: str, factor: int): return f"The result is now stored as {result_filename}." +@_context.tools.append +@StructuredTool.from_function +def extract_features(intensity_image_name:str, label_image_name:str, size : bool = False, intensity : bool = False, perimeter : bool = False, shape : bool = False, position : bool = False, moments : bool = False) -> str: + """Useful for extracting features from a label image and an intensity image.""" + from napari_skimage_regionprops import regionprops_table + + if _context.verbose: + print(f"Extracting features (size={size}, intensity={intensity}, perimeter={perimeter}, shape={shape}, position={position}, moments={moments}) from intensity image {intensity_image_name} and label image {label_image_name}.") + + intensity_image = find_image(_context.variables, intensity_image_name) + label_image = find_image(_context.variables, label_image_name) + + df = regionprops_table(intensity_image, label_image, size=size, intensity=intensity, perimeter=perimeter, shape=shape, position=position, moments=moments) + + result_df_name = make_variable_name(f"extracted_features_{label_image_name}_{intensity_image_name}") + _context.variables[result_df_name] = df + + return f"The resulting dataframe is stored as '{result_df_name}'" + + +@_context.tools.append +@StructuredTool.from_function +def show_dataframe(dataframe_name): + """Useful for showing a dataframe that has been stored before.""" + from IPython.core.display_functions import display + from ._utilities import find_dataframe + + if _context.verbose: + print("Showing dataframe", dataframe_name) + + df = find_dataframe(_context.variables, dataframe_name) + + display(df) + + return f"The dataframe {dataframe_name} has been shown." + + +@_context.tools.append +@StructuredTool.from_function +def list_columns_of_dataframe(dataframe_name): + """Useful for listing the columns of a dataframe that has been stored before.""" + from ._utilities import find_dataframe + + if _context.verbose: + print("Listing columns of dataframe", dataframe_name) + + df = find_dataframe(_context.variables, dataframe_name) + + return f"The dataframe has the columns {list(df.columns)}." + @_context.tools.append @StructuredTool.from_function From f2df566e4b4bbcdcb68ee9fc4454de9a213f703f Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Wed, 9 Aug 2023 17:54:10 +0200 Subject: [PATCH 3/6] better handling of variable names --- src/bia_bob/_tools.py | 11 +++++++---- src/bia_bob/_utilities.py | 1 + 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/bia_bob/_tools.py b/src/bia_bob/_tools.py index 5f2b5c2..57a281f 100644 --- a/src/bia_bob/_tools.py +++ b/src/bia_bob/_tools.py @@ -14,8 +14,9 @@ def load_image(filename: str): if _context.verbose: print("loading image", filename) image = imread(filename) - _context.variables[make_variable_name(filename)] = image - return "The image is now stored as " + filename + variable_name = make_variable_name(filename) + _context.variables[variable_name] = image + return "The image is now stored as " + variable_name @_context.tools.append @@ -27,8 +28,10 @@ def load_csv(filename: str): if _context.verbose: print("loading csv", filename) df = read_csv(filename) - _context.variables[make_variable_name(filename)] = df - return "The csv file is now stored as " + filename + + variable_name = make_variable_name(filename) + _context.variables[variable_name] = df + return "The csv file is now stored as " + variable_name diff --git a/src/bia_bob/_utilities.py b/src/bia_bob/_utilities.py index 1133739..c41f18a 100644 --- a/src/bia_bob/_utilities.py +++ b/src/bia_bob/_utilities.py @@ -3,6 +3,7 @@ def make_variable_name(name: str) -> str: name = name.replace("/", "_") name = name.replace("\\", "_") name = name.replace(" ", "_") + name = name.replace(".", "_") while name.startswith("_"): name = name[1:] From d993fdd5c6384331b0a6de6c5185ac2cb847ca7c Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Wed, 9 Aug 2023 17:54:46 +0200 Subject: [PATCH 4/6] improve system message to prevent display of randomly generated dataframes --- src/bia_bob/_machinery.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/bia_bob/_machinery.py b/src/bia_bob/_machinery.py index dfd8c35..5fa0c59 100644 --- a/src/bia_bob/_machinery.py +++ b/src/bia_bob/_machinery.py @@ -58,7 +58,12 @@ def init_assistant(variables, temperature=0): MEMORY_KEY = "chat_history" _context.memory = ConversationBufferMemory(memory_key=MEMORY_KEY, return_messages=True) - system_message = SystemMessage(content="You are a powerful assistant. After a function has been called to do a task, there is no need do the task again unless the human explicitly asks for it. Answer the human's questions below.") + system_message = SystemMessage(content=""" + You never produce sample data. + You never print out dataframes. + Do not answer questions that are not asked. + Answer the human's questions below and keep your answers short. + """) agent_kwargs = { "system_message": system_message, "extra_prompt_messages": [MessagesPlaceholder(variable_name=MEMORY_KEY)], @@ -71,6 +76,7 @@ def init_assistant(variables, temperature=0): agent_kwargs=agent_kwargs, memory=_context.memory, ) + # store the variables _context.variables = variables From 5dc5416256366503f6a4beef438acf597e4d78c7 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Wed, 9 Aug 2023 17:54:54 +0200 Subject: [PATCH 5/6] added demo notebook --- demo/full_workflow.ipynb | 712 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 712 insertions(+) create mode 100644 demo/full_workflow.ipynb diff --git a/demo/full_workflow.ipynb b/demo/full_workflow.ipynb new file mode 100644 index 0000000..8490f8a --- /dev/null +++ b/demo/full_workflow.ipynb @@ -0,0 +1,712 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b97b3b00-8ff4-4e1b-b7c7-709f87aabc37", + "metadata": {}, + "source": [ + "## Complete bio-image analysis workflows\n", + "In this notebook we use Bob to execute a complete bio-image analysis workflow including image segmentation, feature extraction and plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f4ae3a80-b6ea-4409-95b7-caecd4e4211c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'0.2.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": "7f40c8a0-d0df-4b19-b43b-2d817ac5ee15", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
shape(254, 256)
dtypeuint8
size63.5 kB
min8
max248
\n", + "\n", + "
" + ], + "text/plain": [ + "StackViewNDArray([[ 40, 32, 24, ..., 216, 200, 200],\n", + " [ 56, 40, 24, ..., 232, 216, 216],\n", + " [ 64, 48, 24, ..., 240, 232, 232],\n", + " ...,\n", + " [ 72, 80, 80, ..., 48, 48, 48],\n", + " [ 80, 80, 80, ..., 48, 48, 48],\n", + " [ 96, 88, 80, ..., 48, 48, 48]], dtype=uint8)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "Here is the image \"blobs.tif\":\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%bob Please load the image \"blobs.tif\" and show it." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3a78de42-7960-43f0-a62b-98106e57e75a", + "metadata": { + "tags": [] + }, + "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, ..., 4, 4, 4],\n", + " [0, 0, 0, ..., 4, 4, 4],\n", + " [0, 0, 0, ..., 4, 4, 4],\n", + " ...,\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0]])" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "Here is the segmented image \"segmented_blobs.tif\":\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%bob Please segment the image blobs.tif and show the result." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "15754c9b-1eb9-49c4-b64e-f9acac2bba40", + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "There are 64 objects in the segmented image." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%bob How many objects are there in the segmented image ?" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a24ce242-2e1d-4f62-9dc4-c86fc5a7cd07", + "metadata": { + "tags": [] + }, + "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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
labelareabbox_areaequivalent_diameterconvex_areamax_intensitymean_intensitymin_intensityextentlocal_centroid-0...solidityferet_diameter_maxmajor_axis_lengthminor_axis_lengthorientationeccentricitystandard_deviation_intensityaspect_ratioroundnesscircularity
0114324713.493452164232.0189.370629112.00.5789474.321678...0.87195119.64688316.66028912.825542-1.3946490.63825229.0034191.2989930.6559660.706862
1218223115.222667190224.0180.131868128.00.7878794.252747...0.95789521.37755820.80269711.736074-1.5171930.82566520.9778581.7725430.5354790.803572
2323126017.149879245240.0202.597403120.00.8884624.186147...0.94285727.20294129.06463310.579568-1.4986040.93139825.7683282.7472420.3481710.673382
3447655124.618327490248.0212.302521120.00.86388413.487395...0.97142931.38471031.07510619.852882-0.0355890.76931729.7040171.5652690.6276130.851803
4543752923.588253448248.0216.585812112.00.8260879.826087...0.97544626.92582424.60613023.143996-0.5410880.33957636.9761511.0631760.9189780.915341
..................................................................
596021127016.390654217224.0185.061611120.00.7814818.507109...0.97235018.97366618.48913814.522762-0.2347020.61889327.8453921.2731140.7858851.001435
606146607.65304051224.0175.304348128.00.7666671.891304...0.90196115.03329615.9487143.8039821.5355910.97113927.6538154.1926370.2302590.623448
61628611010.46415889216.0183.720930128.00.7818182.313953...0.96629222.00000021.2614275.426871-1.5608540.96687623.7959603.9178060.2422280.526319
6263781089.96557583248.0185.230769112.00.7222223.102564...0.93975918.02775617.5797996.0286381.5704490.93936133.9188032.9160480.3213490.675000
636451708.05823956248.0190.431373120.00.7285712.490196...0.91071414.03566913.7420795.032414-1.5644390.93053437.7573552.7307130.3438550.747639
\n", + "

64 rows × 21 columns

\n", + "
" + ], + "text/plain": [ + " label area bbox_area equivalent_diameter convex_area max_intensity \n", + "0 1 143 247 13.493452 164 232.0 \\\n", + "1 2 182 231 15.222667 190 224.0 \n", + "2 3 231 260 17.149879 245 240.0 \n", + "3 4 476 551 24.618327 490 248.0 \n", + "4 5 437 529 23.588253 448 248.0 \n", + ".. ... ... ... ... ... ... \n", + "59 60 211 270 16.390654 217 224.0 \n", + "60 61 46 60 7.653040 51 224.0 \n", + "61 62 86 110 10.464158 89 216.0 \n", + "62 63 78 108 9.965575 83 248.0 \n", + "63 64 51 70 8.058239 56 248.0 \n", + "\n", + " mean_intensity min_intensity extent local_centroid-0 ... solidity \n", + "0 189.370629 112.0 0.578947 4.321678 ... 0.871951 \\\n", + "1 180.131868 128.0 0.787879 4.252747 ... 0.957895 \n", + "2 202.597403 120.0 0.888462 4.186147 ... 0.942857 \n", + "3 212.302521 120.0 0.863884 13.487395 ... 0.971429 \n", + "4 216.585812 112.0 0.826087 9.826087 ... 0.975446 \n", + ".. ... ... ... ... ... ... \n", + "59 185.061611 120.0 0.781481 8.507109 ... 0.972350 \n", + "60 175.304348 128.0 0.766667 1.891304 ... 0.901961 \n", + "61 183.720930 128.0 0.781818 2.313953 ... 0.966292 \n", + "62 185.230769 112.0 0.722222 3.102564 ... 0.939759 \n", + "63 190.431373 120.0 0.728571 2.490196 ... 0.910714 \n", + "\n", + " feret_diameter_max major_axis_length minor_axis_length orientation \n", + "0 19.646883 16.660289 12.825542 -1.394649 \\\n", + "1 21.377558 20.802697 11.736074 -1.517193 \n", + "2 27.202941 29.064633 10.579568 -1.498604 \n", + "3 31.384710 31.075106 19.852882 -0.035589 \n", + "4 26.925824 24.606130 23.143996 -0.541088 \n", + ".. ... ... ... ... \n", + "59 18.973666 18.489138 14.522762 -0.234702 \n", + "60 15.033296 15.948714 3.803982 1.535591 \n", + "61 22.000000 21.261427 5.426871 -1.560854 \n", + "62 18.027756 17.579799 6.028638 1.570449 \n", + "63 14.035669 13.742079 5.032414 -1.564439 \n", + "\n", + " eccentricity standard_deviation_intensity aspect_ratio roundness \n", + "0 0.638252 29.003419 1.298993 0.655966 \\\n", + "1 0.825665 20.977858 1.772543 0.535479 \n", + "2 0.931398 25.768328 2.747242 0.348171 \n", + "3 0.769317 29.704017 1.565269 0.627613 \n", + "4 0.339576 36.976151 1.063176 0.918978 \n", + ".. ... ... ... ... \n", + "59 0.618893 27.845392 1.273114 0.785885 \n", + "60 0.971139 27.653815 4.192637 0.230259 \n", + "61 0.966876 23.795960 3.917806 0.242228 \n", + "62 0.939361 33.918803 2.916048 0.321349 \n", + "63 0.930534 37.757355 2.730713 0.343855 \n", + "\n", + " circularity \n", + "0 0.706862 \n", + "1 0.803572 \n", + "2 0.673382 \n", + "3 0.851803 \n", + "4 0.915341 \n", + ".. ... \n", + "59 1.001435 \n", + "60 0.623448 \n", + "61 0.526319 \n", + "62 0.675000 \n", + "63 0.747639 \n", + "\n", + "[64 rows x 21 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "I have extracted the size, shape, and intensity measurements from the image \"blobs.tif\" using the segmented image \"segmented_blobs.tif\" as the label image. The results are stored in a dataframe named \"extracted_features_segmented_blobs_tif_blobs_tif\"." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%bob Please measure size, shape and intensity in blobs.tif using the segmented image of blobs.tif as label image." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0971afa9-a830-4dc1-b43c-92155a8cc470", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/markdown": [ + "The dataframe has the following columns:\n", + "\n", + "1. label\n", + "2. area\n", + "3. bbox_area\n", + "4. equivalent_diameter\n", + "5. convex_area\n", + "6. max_intensity\n", + "7. mean_intensity\n", + "8. min_intensity\n", + "9. extent\n", + "10. local_centroid-0\n", + "11. local_centroid-1\n", + "12. solidity\n", + "13. feret_diameter_max\n", + "14. major_axis_length\n", + "15. minor_axis_length\n", + "16. orientation\n", + "17. eccentricity\n", + "18. standard_deviation_intensity\n", + "19. aspect_ratio\n", + "20. roundness\n", + "21. circularity" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%bob List the columns of that dataframe " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "09eaac65-d4ec-4a71-9049-3e46bd8e86f4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "Here is the plot of the column \"area\" against the column \"circularity\" from the dataframe \"extracted_features_segmented_blobs_tif_blobs_tif\":\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%bob from that dataframe, please plot the column \"area\" against the column \"circularity\"." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85937d26-1dac-4e23-ae90-3b2b6e985d5e", + "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 +} From 9c18ab06ac2485ad5a858df16e1951434d0f8221 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Wed, 9 Aug 2023 18:00:10 +0200 Subject: [PATCH 6/6] add requirement --- setup.cfg | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.cfg b/setup.cfg index 09477aa..a95a731 100644 --- a/setup.cfg +++ b/setup.cfg @@ -36,6 +36,7 @@ install_requires = langchain>=0.0.251 stackview>=0.6.3 napari-segment-blobs-and-things-with-membranes>=0.3.6 + napari-skimage-regionprops pandas seaborn