From 1823535d711583d5267eb2c66fb48281b968dea2 Mon Sep 17 00:00:00 2001 From: DoraDong-2023 Date: Wed, 16 Oct 2024 19:35:15 -0400 Subject: [PATCH] Update documentation for R2APP and Git2APP and report generation 1. update report generation document and code 2. update R2APP and Git2APP documentation --- Dockerfile | 1 + .../components/Chat/ChatMessage.tsx | 4 +- docs/Git2APP.md | 95 +- docs/R2APP.md | 72 +- docs/Report_Generation.md | 12 +- src/R2APP/get_API_init_from_sourcecode_R.py | 11 +- src/report/Chat2PDF.py | 21 +- src/report/Chat2Py.py | 91 +- src/report/Chat2jupyter.py | 40 +- src/report/PNG2report.py | 21 +- src/report/chatbot_ui_history_10-16.ipynb | 1416 +++ src/report/chatbot_ui_history_10-16.json | 9264 +++++++++++++++++ src/report/chatbot_ui_history_10-16.py | 32 + ...hatbot_ui_history_10-16_successful_code.py | 36 + ...reprocessing_and_clustering_3k_PBMCs.ipynb | 895 -- ...Preprocessing_and_clustering_3k_PBMCs.json | 2847 ----- ...o_Preprocessing_and_clustering_3k_PBMCs.py | 46 - 17 files changed, 10917 insertions(+), 3987 deletions(-) create mode 100644 src/report/chatbot_ui_history_10-16.ipynb create mode 100644 src/report/chatbot_ui_history_10-16.json create mode 100644 src/report/chatbot_ui_history_10-16.py create mode 100644 src/report/chatbot_ui_history_10-16_successful_code.py delete mode 100644 src/report/demo_Preprocessing_and_clustering_3k_PBMCs.ipynb delete mode 100644 src/report/demo_Preprocessing_and_clustering_3k_PBMCs.json delete mode 100644 src/report/demo_Preprocessing_and_clustering_3k_PBMCs.py diff --git a/Dockerfile b/Dockerfile index 0e1ddfc..08faa8a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -54,6 +54,7 @@ COPY src/retrievers /app/src/retrievers COPY images /app/images #COPY src/tmp /app/src/tmp COPY data/standard_process/${LIB}/ /app/data/standard_process/${LIB}/ +COPY data/standard_process/base/ /app/data/standard_process/base/ COPY data/autocoop/${LIB}/ /app/data/autocoop/${LIB}/ COPY data/conversations/ /app/data/conversations/ COPY data/others-data/ /app/data/others-data/ diff --git a/chatbot_ui_biomania/components/Chat/ChatMessage.tsx b/chatbot_ui_biomania/components/Chat/ChatMessage.tsx index 441016c..22e7eec 100644 --- a/chatbot_ui_biomania/components/Chat/ChatMessage.tsx +++ b/chatbot_ui_biomania/components/Chat/ChatMessage.tsx @@ -221,13 +221,13 @@ export const ChatMessage: FC = memo(({ message, messageIndex, onEdit}) => return !inline ? ( ) : ( - + {children} ); diff --git a/docs/Git2APP.md b/docs/Git2APP.md index a48d930..263f3e5 100644 --- a/docs/Git2APP.md +++ b/docs/Git2APP.md @@ -116,41 +116,17 @@ Install your GitHub repository to your local machine using the `pip install` com ```bash # install remotely -pip install git+https://github.com/your_github_page/your_repository.git. +pip install git+https://github.com/your_github_page/your_repository.git # Or build locally pip install -e . ``` ## Step 2: Use BioMANIA -Now that your GitHub repository is properly installed, you can create a BioMANIA app to use it. Feel free to skip any Optional steps to make it easy. Here are the steps: +Now that your GitHub repository is properly installed, you can create a BioMANIA app to use it. Just treat your library as a PyPI package, and follow the steps in [the steps in readme file.](../docs/PyPI2APP.md), start from adding the information to the `Lib_cheatsheet.py`. -### 2.1. Create BioMANIA app: - -#### 2.1.1 Generate Initial API Configuration: -To obtain `API_init_prepare.json`, use the following script: -```shell -export LIB=scanpy -python Git2APP/get_API_init_from_sourcecode.py --LIB ${LIB} -``` - -Note: You have the option to alter the filtering rules by modifying filter_specific_apis. - -#### 2.1.2. Refine Function Definitions and Docstrings: -(Optional) Now, you need to add docstrings in your source code and refine the function definitions. You can either choose running our provided script and get `API_init.json` with GPT: - -```shell -python Git2APP/get_API_docstring_from_sourcecode.py --LIB ${LIB} -``` - -Tips -- This script is designed to execute only on APIs lacking docstrings or well-documented parameters. It automatically skips APIs that meet the established documentation standards. Please note that running this script requires a paid OpenAI account. - -- This script is based on LLM responses for modification, and the quality of the results may not be entirely satisfactory. Users need to ensure that the necessary parameters type are provided for inference, as `None` type may lead to execution failures in the API due to missing essential parameters. - -- To accommodate the fact that `args`, `kwargs`, and similar parameters in general APIs are optional, we currently filter them out during prediction. Therefore, it's advisable to avoid using args as parameters in the code. - -It is better that if you can design the docstrings by yourself as it is more accurate. `NumPy` format is preferred than `reStructuredText` and `Google` format. Here's a basic example of an effective docstring : +### Tips: Refine Function Definitions and Docstrings: +(Optional) If you need to add docstrings in your source code and refine the function definitions. You can either choose using GPT or design by yourself. The latter is better as it is more accurate. `NumPy` format is preferred than `reStructuredText` and `Google` format. Here's a basic example of an effective docstring : ```python from typing import Union @@ -176,76 +152,25 @@ def add(a:int, b:int) -> int: return a + b ``` -You can refer to the prompts available in [BioMANIA](https://www.biorxiv.org/content/10.1101/2023.10.29.564479v1) to add the function body, or either using the [prompt](./src/Git2APP/get_API_docstring_from_sourcecode.py) that modified based on that. - -If you already have a well-documented code, generate API_init.json with: -```shell -cp -r data/standard_process/${LIB}/API_init_prepare.json data/standard_process/${LIB}/API_init.json -``` - -#### 2.1.3. Run Training Scripts: -For subsequent steps, start from obtaining `API_composite.json` of [`Run with script/Training`](./PyPI2APP.md#training) section. Following these instructions will result in the generation of data files in data/standard_process/your_project_name and model files in hugging_models. +You can refer to the prompts available in [BioMANIA](https://www.biorxiv.org/content/10.1101/2023.10.29.564479) to add the function body, or either using the [prompt](./src/Git2APP/get_API_docstring_from_sourcecode.py) that modified based on that. -```python -data/standard_process/your_project_name -├── API_composite.json -├── API_init.json -├── API_init_prepare.json -├── API_inquiry.json -├── API_inquiry_annotate.json -├── API_instruction_testval_query_ids.json -├── api_data.csv -├── centroids.pkl -├── retriever_train_data -│   ├── corpus.tsv -│   ├── qrels.test.tsv -│   ├── qrels.train.tsv -│   ├── qrels.val.tsv -│   ├── test.json -│   ├── test.query.txt -│   ├── train.json -│   ├── train.query.txt -│   ├── val.json -│   └── val.query.txt -└── vectorizer.pkl - -hugging_models -└── retriever_model_finetuned - ├── your_project_name - │   ├── assigned - │   │   ├── 1_Pooling - │   │   ├── README.md - │   │   ├── config.json - │   │   ├── config_sentence_transformers.json - │   │   ├── eval - │   │   ├── model.safetensors - │   │   ├── modules.json - │   │   ├── sentence_bert_config.json - │   │   ├── special_tokens_map.json - │   │   ├── tokenizer.json - │   │   ├── tokenizer_config.json - │   │   └── vocab.txt - │   └── tensorboard - │   └── name_desc -``` +If you already have a well-documented code, just ignore this step and follow the steps in readme file. -### 2.2 Add logo +### Tips: Add logo to UI Add a logo image to `BioMANIA/chatbot_ui_biomania/public/apps/` and modify the link in `BioMANIA/chatbot_ui_biomania/components/Chat/LibCardSelect.tsx`. Be mindful of the capitalization in library names, as it affects the recognition of the related model data loading paths. -### 2.3 Use UI service. +### Tips: Use UI service. Follow the steps in [`Run with script/Inference`](../README.md#inference) section in `README` to start UI service. Don’t forget to set an OpenAI key in `.env` file as recommended in `README`. Remember to update the app's accordingly to your repository improvements. -**Tips: Currently, we do not support real-time communication. Therefore, if there is content that requires a long time to run, such as training a model, it is best to train only one epoch per inquiry. We might plan to support real-time display of results in the near future.** - -### 2.4 Share your APP! +### Tips: Share your APP! -Follow the steps in [`Share your APP`](../README.md#share-your-app) section in `README` to introduce your tool to others! +If you want your app to be used by others, follow the steps in [`Share your APP`](../README.md#share-your-app) section in `README` to introduce your tool to others! I hope this tutorial helps you create your BioMANIA app with your GitHub-hosted package. If you have any further questions or need assistance with specific steps, feel free to ask! diff --git a/docs/R2APP.md b/docs/R2APP.md index 7bf5c08..54ccd57 100644 --- a/docs/R2APP.md +++ b/docs/R2APP.md @@ -10,78 +10,30 @@ Before starting, ensure that R and `rpy2` are installed. `rpy2` allows for runni ```shell pip install rpy2 ``` +- **Install your R lib**: In terminal, enter `R` to enter R environment, and install its package +```shell +R +> install.packages('Your Package Name') +> exit +``` #### Step 2: Generating API Initialization File -Use a Python script to generate the `./data/R/{Your_R_Library_Name}/API_init.json` file. This file contains initial information about the APIs in the R package. +Use a Python script to generate the `./data/standard_process/{Your_R_Library_Name}/API_init.json` file. This file contains initial information about the APIs in the R package. - Run the following command: ```bash -python dataloader/get_API_init_from_sourcecode_R.py --LIB [Your_R_Library_Name] -cp -r ./data/R/{Your_R_Library_Name}/API_init.json /data/R/{Your_R_Library_Name}/API_composite.json -``` - -#### Step 3: Preparing Retriever Data -Prepare the data required for the retriever model using another Python script. This process generates the instruction under `./data/R/{your_r_lib_name}/API_inquiry.json` file and `./data/R/{your_r_lib_name}/retriever_train_data/` folder. - -- Execute the command: -```bash -python dataloader/prepare_retriever_data.py --LIB [Your_R_Library_Name] -``` - -#### Step 4: Training Models -Train the chat classification and retriever models. These models are crucial for the app's functionality. - -1. **Chitchat Classification Model**: -- Train the model using the following command: -```bash -python models/chitchat_classification.py --LIB ${LIB} -``` - -2. **Retriever Model**: -- Train the model with this command (adjust the command with necessary parameters): -```bash -export LIB=scanpy -CUDA_VISIBLE_DEVICES=0 -mkdir ./hugging_models/retriever_model_finetuned/${LIB} -python models/train_retriever.py \ ---data_path ./data/standard_process/${LIB}/retriever_train_data/ \ ---model_name bert-base-uncased \ ---output_path ./hugging_models/retriever_model_finetuned/${LIB} \ ---num_epochs 25 \ ---train_batch_size 32 \ ---learning_rate 1e-5 \ ---warmup_steps 500 \ ---max_seq_length 256 \ ---optimize_top_k 3 \ ---plot_dir ./plot/${LIB}/retriever/ -``` - -#### Step 5: Use model -Start back-end UI service with: -```bash -export LIB=ggplot2 -CUDA_VISIBLE_DEVICES=0 \ -python deploy/inference_dialog_server_R.py \ - --retrieval_model_path ./hugging_models/retriever_model_finetuned/${LIB}/assigned \ - --top_k 3 -``` - -Install and start the front-end service in a new terminal with: -```bash -cd src/chatbot_ui_biomania -npm i # install -export BACKEND_URL="https://[ngrok_id].ngrok-free.app" # "http://localhost:5000"; -npm run dev # run +python -m src.R2APP.get_API_init_from_sourcecode_R --LIB [Your_R_Library_Name] # e.g. Seurat, ggplot2 +cp -r ./data/standard_process/{Your_R_Library_Name}/API_init.json /data/standard_process/{Your_R_Library_Name}/API_composite.json ``` -Your chatbot server is now operational at `http://localhost:3000/en`, primed to process user queries. +#### Follow the [remaining steps](PyPI2APP) from preparing data synthesis on. Remember to add the information into `Lib_cheatsheet.py` #### Key Differences Between R and Python Integration -- **Library Loading**: In R, use `library(LIB)` to load packages directly. There's no need to modify `Lib_cheatsheet.py` as in Python. +- **Library Loading**: In R, use `library(LIB)` to load packages directly. - **Documentation Access**: R documentation can be accessed through `help()`, `??`, or the `.__doc__` attribute after converting R functions to Python via `rpy2`. - **Arguments Information**: R documentation didn't always provide `type` information for parameters. -- **Simplified Process**: The process for R integration is more straightforward, focusing primarily on data preparation and model training, without the need to adjust library settings extensively. +- **Simplified Process**: The process for R integration is more straightforward, focusing primarily on data preparation and model training, without the need to search for more documentation resources. #### Final Notes This framework outlines the key steps and differences for integrating an R package into BioMANIA. Adjust the Python commands and paths according to your package's specifics. If you have any questions or need assistance with specific steps, feel free to reach out! \ No newline at end of file diff --git a/docs/Report_Generation.md b/docs/Report_Generation.md index c61ba52..68cbd86 100644 --- a/docs/Report_Generation.md +++ b/docs/Report_Generation.md @@ -9,7 +9,7 @@ Firstly, press `export chat` button on UI to get the chat json data. Convert the ```bash # cd src -python report/Chat2Py.py report/demo_Preprocessing_and_clustering_3k_PBMCs.json +python -m report.Chat2Py report/chatbot_ui_history_10-16.json ``` ![](https://github.com/batmen-lab/BioMANIA/tree/main/images/pyfile.jpg) @@ -20,18 +20,18 @@ Convert the chat JSON into an [ipynb report](https://github.com/batmen-lab/BioMA ```bash # cd src -python report/Chat2jupyter.py report/demo_Preprocessing_and_clustering_3k_PBMCs.json +python -m report.Chat2jupyter report/chatbot_ui_history_10-16.json ``` ![](https://github.com/batmen-lab/BioMANIA/tree/main/images/jupyter.jpg) -### For performance report +### For performance report (under developing) Combine and sort the performance figures into a short report. ```bash # cd src -python report/PNG2report.py scanpy +python -m report.PNG2report scanpy ``` Please note that the generation of this report must be based on the premise that the retriever models have already been trained, and the gpt baseline has already been tested. You need to first obtain the results of each model before running this script. Here is a reference for a [demo report](https://github.com/batmen-lab/BioMANIA/tree/main/src/report/performance_report.pdf). @@ -39,13 +39,13 @@ Please note that the generation of this report must be based on the premise that ![](https://github.com/batmen-lab/BioMANIA/tree/main/images/performance_report.jpg) -### For common issue report +### For common issue report (under developing) Displaying common issues in the process of converting Python tools into libraries ```bash # cd src -python report/Py2report.py scanpy +python -m report.Py2report scanpy ``` The output files are located in the ./report folder. diff --git a/src/R2APP/get_API_init_from_sourcecode_R.py b/src/R2APP/get_API_init_from_sourcecode_R.py index ce7ed48..8926eb8 100644 --- a/src/R2APP/get_API_init_from_sourcecode_R.py +++ b/src/R2APP/get_API_init_from_sourcecode_R.py @@ -6,8 +6,8 @@ import pydoc, argparse, json, re, os, collections, inspect, importlib, typing, functools from docstring_parser import parse from langchain.document_loaders import BSHTMLLoader -from configs.model_config import ANALYSIS_PATH, get_all_variable_from_cheatsheet, get_all_basic_func_from_cheatsheet -from dataloader.extract_function_from_sourcecode import get_returnparam_docstring +from ..configs.model_config import ANALYSIS_PATH, get_all_variable_from_cheatsheet, get_all_basic_func_from_cheatsheet +from ..dataloader.extract_function_from_sourcecode import get_returnparam_docstring import rpy2.robjects as robjects from rpy2.robjects.packages import importr @@ -196,20 +196,19 @@ def get_r_function_doc_rd2txt(package_name, function_name): def main_get_API_init(): # import R - ggplot2 = importr('ggplot2') + library = importr(args.LIB) # get functions name - package_functions = [func for func in dir(ggplot2) if not func.startswith("_")] + package_functions = [func for func in dir(library) if not func.startswith("_")] api_info = {} for func in package_functions: try: - r_func = getattr(ggplot2, func, None) + r_func = getattr(library, func, None) if r_func: doc_string = r_func.__doc__ # doc_string = robjects.r('capture.output(??("{function_name}", package="{package_name}"))'.format(function_name=func, package_name=args.LIB)) if doc_string: # Parsing the provided docstring with the new function parsed_json_structure = parse_r_docstring_to_json_structure(doc_string, func) - print(parsed_json_structure) api_info[func] = parsed_json_structure except: pass diff --git a/src/report/Chat2PDF.py b/src/report/Chat2PDF.py index 5b430c4..8696266 100644 --- a/src/report/Chat2PDF.py +++ b/src/report/Chat2PDF.py @@ -10,7 +10,26 @@ from reportlab.lib.pagesizes import letter from reportlab.pdfgen import canvas from reportlab.lib.utils import simpleSplit -from ..gpt.utils import load_json +import json + +def load_json(filename: str) -> dict: + """ + Load JSON data from a specified file. + + Parameters + ---------- + filename : str + The path to the JSON file to be loaded. + + Returns + ------- + dict + The data loaded from the JSON file. + """ + with open(filename, 'r') as file: + data = json.load(file) + return data + # draw text with markdown style def draw_markdown_text(c, text, line_num, font_name="Helvetica", font_size=10, leading=15, max_width=440): diff --git a/src/report/Chat2Py.py b/src/report/Chat2Py.py index 3198edb..b995a6f 100644 --- a/src/report/Chat2Py.py +++ b/src/report/Chat2Py.py @@ -1,39 +1,53 @@ """ Author: Zhengyuan Dong Email: zydong122@gmail.com +Open Date: Sep 01, 2023 +Last Edited: Oct 16, 2024 Description: This script contains functions to extract tasks from JSON chat files and generate Python code. """ -from ..gpt.utils import load_json + +import json +def load_json(filename: str) -> dict: + """ + Load JSON data from a specified file. + + Parameters + ---------- + filename : str + The path to the JSON file to be loaded. + + Returns + ------- + dict + The data loaded from the JSON file. + """ + with open(filename, 'r') as file: + data = json.load(file) + return data def extract_tasks(file_path): data = load_json(file_path) result_data = [] + code_status = {} + last_executed_code = None for item in data['history']: - code_status = {} for message in item['messages']: - record_status = False - success_flag = False - fail_flag = False task_title_list = [] for task in message.get('tools', []): - if task['method_name'] == "on_agent_action" and "block_id" in task and "code" in task["block_id"]: - code = task['task'] - record_status = True - task_title_list.append(task.get('task_title', '')) - if record_status: - if "Executed results [Success]" in task_title_list: - success_flag = True - elif "Executed results [Fail]" in task_title_list: - fail_flag = True - # one True, another False - assert not(success_flag and fail_flag) - assert (success_flag | fail_flag) - code_status[code] = "Success" if success_flag else "Fail" if fail_flag else "No result" - assert code_status[code]!='No result' - result_data.append(code_status) - for result in result_data: - if "Success" in result: - assert not "Fail" in result, "Both success and fail task results found in the same message!" + if "method_name" in task and task['method_name'] == "on_agent_action" and "code" in task["block_id"]: + last_executed_code = task['task'] + #print(f"Found Executed Code: {last_executed_code}") + if "Executed results [Success]" in task.get('task_title', ''): + #print(f"Success found for code: {last_executed_code}") + code_status[last_executed_code] = "Success" + last_executed_code = None + elif "Executed results [Fail]" in task.get('task_title', ''): + #print(f"Failure found for code: {last_executed_code}") + code_status[last_executed_code] = "Fail" + last_executed_code = None + #if last_executed_code: + # print(f"No result for code yet: {last_executed_code}") + result_data.append(code_status) return result_data import os @@ -41,13 +55,36 @@ def generate_python_code(result_data, file_path): code_snippets = [] for result in result_data: for code, status in result.items(): - if status == "Success": + if code: + pass + else: + continue + if code.startswith("from"): + if '\n' in code: + code_snippets.append(code.split('\n')[0]) + else: + code_snippets.append(code) + if status == "Success" and code is not None: code_snippets.append(code) - python_code = "\n".join(code_snippets) - file_name = os.path.splitext(os.path.basename(file_path))[0] # Extract filename without extension + python_code = "\n".join([code for code in code_snippets if code is not None]) + python_code = deduplicate_python_code(python_code) + file_name = os.path.splitext(os.path.basename(file_path))[0] output_file = f"{file_name}.py" - with open(os.path.join('report',output_file), "w") as file: + output_path = os.path.join('report', output_file) + os.makedirs(os.path.dirname(output_path), exist_ok=True) + with open(output_path, "w") as file: file.write(python_code) + print(f"Python code saved to: {output_path}") + +def deduplicate_python_code(python_code): + seen_code = set() + deduplicated_code = [] + code_lines = python_code.split("\n") + for line in code_lines: + if line not in seen_code: + deduplicated_code.append(line) + seen_code.add(line) + return "\n".join(deduplicated_code) import inspect __all__ = list(set([name for name, obj in locals().items() if not name.startswith('_') and (inspect.isfunction(obj) or (inspect.isclass(obj) and name != '__init__') or (inspect.ismethod(obj) and not name.startswith('_')))])) diff --git a/src/report/Chat2jupyter.py b/src/report/Chat2jupyter.py index f6f4b89..d52512c 100644 --- a/src/report/Chat2jupyter.py +++ b/src/report/Chat2jupyter.py @@ -1,11 +1,29 @@ import nbformat from nbformat.v4 import new_notebook, new_markdown_cell, new_code_cell -from ..gpt.utils import load_json +import json + +def load_json(filename: str) -> dict: + """ + Load JSON data from a specified file. + + Parameters + ---------- + filename : str + The path to the JSON file to be loaded. + + Returns + ------- + dict + The data loaded from the JSON file. + """ + with open(filename, 'r') as file: + data = json.load(file) + return data + # Define a function to extract the relevant elements from the JSON content def extract_elements(json_content): extracted_elements = [] - for chat in json_content['history']: for message in chat['messages']: if message['role'] == 'assistant': @@ -21,13 +39,13 @@ def extract_elements(json_content): 'type': 'markdown', 'content': f"**{tool['task_title']}**\n\n{tool['task']}" }) - if tool['imageData'].strip(): + if 'imageData' in tool and tool['imageData'].strip(): # Adding image data extracted_elements.append({ 'type': 'image', 'content': f"![Image](data:image/png;base64,{tool['imageData']})" }) - if tool['tableData'].strip('\"'): + if 'tableData' in tool and tool['tableData'].strip('\"'): # Convert table data to markdown table format table_md = string_to_markdown_table(tool['tableData'].strip('\"')) extracted_elements.append({ @@ -37,15 +55,15 @@ def extract_elements(json_content): return extracted_elements def string_to_markdown_table(table_string): - # Split the string into rows + # Split the string into rows by newline rows = table_string.strip().split("\n") - # Determine the number of columns by the first row - num_columns = len(rows[0].split()) - # Create the header row and the separator row for markdown - header_row = "| " + " | ".join(["Column " + str(i) for i in range(1, num_columns + 1)]) + " |" + # Convert each row into columns by splitting on commas + markdown_rows = ["| " + " | ".join(row.split(",")) + " |" for row in rows] + # Generate a separator row for markdown (assuming all rows have the same number of columns) + num_columns = len(markdown_rows[0].split("|")) - 2 # Because of leading/trailing "|" separator_row = "|-" + "-|-".join(["" for _ in range(num_columns)]) + "-|" - # Convert each row to markdown format - markdown_rows = [header_row, separator_row] + ["| " + " | ".join(row.split()) + " |" for row in rows] + # Insert the separator after the first row (which is assumed to be the header) + markdown_rows.insert(1, separator_row) return "\n".join(markdown_rows) # Helper function to generate a Markdown table from data diff --git a/src/report/PNG2report.py b/src/report/PNG2report.py index 69dcd1b..34230b2 100644 --- a/src/report/PNG2report.py +++ b/src/report/PNG2report.py @@ -9,7 +9,26 @@ import argparse import matplotlib.pyplot as plt import pandas as pd -from ..gpt.utils import load_json +import json + +def load_json(filename: str) -> dict: + """ + Load JSON data from a specified file. + + Parameters + ---------- + filename : str + The path to the JSON file to be loaded. + + Returns + ------- + dict + The data loaded from the JSON file. + """ + with open(filename, 'r') as file: + data = json.load(file) + return data + # Parsing arguments for the JSON file path parser = argparse.ArgumentParser(description="") diff --git a/src/report/chatbot_ui_history_10-16.ipynb b/src/report/chatbot_ui_history_10-16.ipynb new file mode 100644 index 0000000..317ebf4 --- /dev/null +++ b/src/report/chatbot_ui_history_10-16.ipynb @@ -0,0 +1,1416 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5a72797e", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.datasets.pbmc3k_processed**\n", + "\n", + "The task is to load a built-in dataset that can be used for grouping similar data points together, which is important in clustering analysis. We solved it by using the function `scanpy.datasets.pbmc3k_processed()`, which provides a pre-processed collection of data from 3,000 blood cells for our analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b707f93", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.datasets import pbmc3k_processed\n", + "result_1 = pbmc3k_processed()" + ] + }, + { + "cell_type": "markdown", + "id": "5a7ece8b", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n", + " var: 'n_cells'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "02fd213a", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "e75c2ac6", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain |\n", + "|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 781 | 0.030177759 | 2419.0 | CD4 T cells |\n", + "| AAACATTGAGCTAC-1 | 1352 | 0.037935957 | 4903.0 | B cells |\n", + "| AAACATTGATCAGC-1 | 1131 | 0.008897362 | 3147.0 | CD4 T cells |\n", + "| AAACCGTGCTTCCG-1 | 960 | 0.017430846 | 2639.0 | CD14+ Monocytes |\n", + "| AAACCGTGTATGCG-1 | 522 | 0.012244898 | 980.0 | NK cells |" + ] + }, + { + "cell_type": "markdown", + "id": "de013e8d", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pp.calculate_qc_metrics**\n", + "\n", + "The task is to filter and assess data quality based on specific metrics. We solved it by using a function called `calculate_qc_metrics` from the Scanpy library, which analyzes the data, calculates various quality control measurements, and can update the results directly in the data structure we are working with." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9943e262", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pp import calculate_qc_metrics\n", + "result_2 = calculate_qc_metrics(result_1, qc_vars=['mito'], inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "199ecc9e", + "metadata": {}, + "source": [ + "**Executed results [Fail]**\n", + "\n", + "KeyError: 'mito'\n", + "\n", + "The above exception was the direct cause of the following exception:\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/home/z6dong/BioChat/refer/src/BioMANIA/src/inference/execution_UI.py\", line 524, in execute_api_call\n", + " exec(api_call_code, locals(), globals())\n", + " File \"\", line 1, in \n", + " File \"/home/z6dong/anaconda3/envs/biomania_39/lib/python3.9/site-packages/scanpy/preprocessing/_qc.py\", line 316, in calculate_qc_metrics\n", + " obs_metrics = describe_obs(\n", + " File \"/home/z6dong/anaconda3/envs/biomania_39/lib/python3.9/site-packages/scanpy/preprocessing/_qc.py\", line 129, in describe_obs\n", + " X[:, adata.var[qc_var].values].sum(axis=1)\n", + " File \"/home/z6dong/anaconda3/envs/biomania_39/lib/python3.9/site-packages/pandas/core/frame.py\", line 3896, in __getitem__\n", + " indexer = self.columns.get_loc(key)\n", + " File \"/home/z6dong/anaconda3/envs/biomania_39/lib/python3.9/site-packages/pandas/core/indexes/base.py\", line 3797, in get_loc\n", + " raise KeyError(key) from err\n", + "KeyError: 'mito'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd9809f4", + "metadata": {}, + "outputs": [], + "source": [ + "result_1.var['mito'] = result_1.var_names.str.startswith('MT-')\n", + "result_2 = calculate_qc_metrics(result_1, qc_vars=['mito'], inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "3d0ddb50", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain', 'n_genes_by_counts', 'log1p_n_genes_by_counts', 'total_counts', 'log1p_total_counts', 'pct_counts_in_top_50_genes', 'pct_counts_in_top_100_genes', 'pct_counts_in_top_200_genes', 'pct_counts_in_top_500_genes', 'total_counts_mito', 'log1p_total_counts_mito', 'pct_counts_mito'\n", + " var: 'n_cells', 'mito', 'n_cells_by_counts', 'mean_counts', 'log1p_mean_counts', 'pct_dropout_by_counts', 'total_counts', 'log1p_total_counts'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "fe6382af", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "779a0f97", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain | n_genes_by_counts | log1p_n_genes_by_counts | total_counts | log1p_total_counts | pct_counts_in_top_50_genes | pct_counts_in_top_100_genes | pct_counts_in_top_200_genes | pct_counts_in_top_500_genes | total_counts_mito | log1p_total_counts_mito | pct_counts_mito |\n", + "|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 781 | 0.030177759 | 2419.0 | CD4 T cells | 1838 | 7.516977224604321 | -54.403603 | | -394.0494943827394 | -591.2966152833859 | -652.8546350200518 | -615.3194478198695 | 0.0 | 0.0 | -0.0 |\n", + "| AAACATTGAGCTAC-1 | 1352 | 0.037935957 | 4903.0 | B cells | 1838 | 7.516977224604321 | -74.253 | | -274.4154552858986 | -425.13938623511416 | -584.6912336607829 | -594.6293800075192 | 0.0 | 0.0 | -0.0 |\n", + "| AAACATTGATCAGC-1 | 1131 | 0.008897362 | 3147.0 | CD4 T cells | 1838 | 7.516977224604321 | 14.642954 | 2.7500205 | 1459.7248839897748 | 2207.40727811518 | 2908.333210674569 | 2803.6175781949623 | 0.0 | 0.0 | 0.0 |\n", + "| AAACCGTGCTTCCG-1 | 960 | 0.017430846 | 2639.0 | CD14+ Monocytes | 1838 | 7.516977224604321 | 25.272524 | 3.2685237 | 780.8842828960819 | 1223.1575037163923 | 1638.7717176974238 | 1565.8289183288766 | 0.0 | 0.0 | 0.0 |\n", + "| AAACCGTGTATGCG-1 | 522 | 0.012244898 | 980.0 | NK cells | 1838 | 7.516977224604321 | 6.548219 | 2.0213118 | 3784.372483863411 | 5127.23927008491 | 5156.42582645063 | 4886.076713670838 | 0.0 | 0.0 | 0.0 |" + ] + }, + { + "cell_type": "markdown", + "id": "3e66dc02", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pp.normalize_total**\n", + "\n", + "The task is to normalize the data so that we can compare different cells fairly. We solved it by using a function that adjusts the total counts in each cell, making them equal, optionally excluding genes that are very highly expressed to avoid skewing the results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2e5764f", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pp import normalize_total\n", + "result_3 = normalize_total(result_1, target_sum=1000000.0, layers='target_sum=1e6, max_fraction=0.05', inplace=True, copy=False)" + ] + }, + { + "cell_type": "markdown", + "id": "0d175d59", + "metadata": {}, + "source": [ + "**Executed results [Fail]**\n", + "\n", + "ValueError: `layers` needs to be a list of strings or 'all', not 'target_sum=1e6, max_fraction=0.05'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dfeccd9c", + "metadata": {}, + "outputs": [], + "source": [ + "result_3 = normalize_total(result_1, target_sum=1e6, max_fraction=0.05, inplace=True, copy=False)" + ] + }, + { + "cell_type": "markdown", + "id": "81ace85c", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "Executed successfully! No new variable obtained" + ] + }, + { + "cell_type": "markdown", + "id": "f34c9b55", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.tl.leiden**\n", + "\n", + "The task is to group similar cells into clusters using a clustering algorithm after processing the data. We solved it by using the Leiden algorithm through a specific function that analyzes the cell data and creates subgroups based on their similarities." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5fdfe457", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.tl import leiden\n", + "result_4 = leiden(result_1, key_added='louvain', copy=False)" + ] + }, + { + "cell_type": "markdown", + "id": "573f69b1", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain', 'n_genes_by_counts', 'log1p_n_genes_by_counts', 'total_counts', 'log1p_total_counts', 'pct_counts_in_top_50_genes', 'pct_counts_in_top_100_genes', 'pct_counts_in_top_200_genes', 'pct_counts_in_top_500_genes', 'total_counts_mito', 'log1p_total_counts_mito', 'pct_counts_mito'\n", + " var: 'n_cells', 'mito', 'n_cells_by_counts', 'mean_counts', 'log1p_mean_counts', 'pct_dropout_by_counts', 'total_counts', 'log1p_total_counts'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "adf77b68", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "1282c9c9", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain | n_genes_by_counts | log1p_n_genes_by_counts | total_counts | log1p_total_counts | pct_counts_in_top_50_genes | pct_counts_in_top_100_genes | pct_counts_in_top_200_genes | pct_counts_in_top_500_genes | total_counts_mito | log1p_total_counts_mito | pct_counts_mito |\n", + "|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 781 | 0.030177759 | 2419.0 | 0 | 1838 | 7.516977224604321 | -54.403603 | | -394.0494943827394 | -591.2966152833859 | -652.8546350200518 | -615.3194478198695 | 0.0 | 0.0 | -0.0 |\n", + "| AAACATTGAGCTAC-1 | 1352 | 0.037935957 | 4903.0 | 2 | 1838 | 7.516977224604321 | -74.253 | | -274.4154552858986 | -425.13938623511416 | -584.6912336607829 | -594.6293800075192 | 0.0 | 0.0 | -0.0 |\n", + "| AAACATTGATCAGC-1 | 1131 | 0.008897362 | 3147.0 | 0 | 1838 | 7.516977224604321 | 14.642954 | 2.7500205 | 1459.7248839897748 | 2207.40727811518 | 2908.333210674569 | 2803.6175781949623 | 0.0 | 0.0 | 0.0 |\n", + "| AAACCGTGCTTCCG-1 | 960 | 0.017430846 | 2639.0 | 1 | 1838 | 7.516977224604321 | 25.272524 | 3.2685237 | 780.8842828960819 | 1223.1575037163923 | 1638.7717176974238 | 1565.8289183288766 | 0.0 | 0.0 | 0.0 |\n", + "| AAACCGTGTATGCG-1 | 522 | 0.012244898 | 980.0 | 4 | 1838 | 7.516977224604321 | 6.548219 | 2.0213118 | 3784.372483863411 | 5127.23927008491 | 5156.42582645063 | 4886.076713670838 | 0.0 | 0.0 | 0.0 |" + ] + }, + { + "cell_type": "markdown", + "id": "a4090c21", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pl.draw_graph**\n", + "\n", + "The task is to create a scatter plot that visualizes different clusters in the data. We solved it by using the `scanpy.pl.draw_graph` function, which allows us to specify colors for annotations and plot styles to effectively represent the clusters." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "17c18008", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pl import draw_graph\n", + "result_5 = draw_graph(result_1, color='louvain', show=True)" + ] + }, + { + "cell_type": "markdown", + "id": "5cd231cd", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "Executed successfully! No new variable obtained" + ] + }, + { + "cell_type": "markdown", + "id": "d95c32f5", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the obtained figure. Try to zoom in or out the figure." + ] + }, + { + "cell_type": "markdown", + "id": "0a34df33", + "metadata": {}, + "source": [ + "![Image](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "42e81496", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We interpret the obtained figure: The scatter plot indicates distinct clusters corresponding to different communities, with several clearly separated groupings represented by various colors, suggesting the presence of diverse subpopulations within the data." + ] + }, + { + "cell_type": "markdown", + "id": "910924d1", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.datasets.pbmc3k_processed**\n", + "\n", + "The task is to load a ready-to-use dataset that we can analyze for clustering. We solved it by using the function `scanpy.datasets.pbmc3k_processed()`, which gives us a pre-processed data matrix of specific blood cells for our analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c7c7c74d", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.datasets import pbmc3k_processed\n", + "result_1 = pbmc3k_processed()" + ] + }, + { + "cell_type": "markdown", + "id": "3c8596fc", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n", + " var: 'n_cells'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "88d59dc9", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "e65ecfea", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain |\n", + "|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 781 | 0.030177759 | 2419.0 | CD4 T cells |\n", + "| AAACATTGAGCTAC-1 | 1352 | 0.037935957 | 4903.0 | B cells |\n", + "| AAACATTGATCAGC-1 | 1131 | 0.008897362 | 3147.0 | CD4 T cells |\n", + "| AAACCGTGCTTCCG-1 | 960 | 0.017430846 | 2639.0 | CD14+ Monocytes |\n", + "| AAACCGTGTATGCG-1 | 522 | 0.012244898 | 980.0 | NK cells |" + ] + }, + { + "cell_type": "markdown", + "id": "ebea6d30", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pp.filter_cells**\n", + "\n", + "The task is to filter out unwanted cells from a dataset based on specific criteria like the minimum number of genes expressed or the number of counts. We solved it by using the `scanpy.pp.filter_cells` function, which allows us to specify thresholds to keep only the reliable cells, ensuring our data is more accurate for analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "36ed1167", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pp import filter_cells\n", + "result_3 = filter_cells(result_1, min_genes=3, inplace=True, copy=False)" + ] + }, + { + "cell_type": "markdown", + "id": "59d11c66", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n", + " var: 'n_cells'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "983d9661", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "0b1861a3", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain |\n", + "|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 144 | 0.030177759 | 2419.0 | CD4 T cells |\n", + "| AAACATTGAGCTAC-1 | 341 | 0.037935957 | 4903.0 | B cells |\n", + "| AAACATTGATCAGC-1 | 217 | 0.008897362 | 3147.0 | CD4 T cells |\n", + "| AAACCGTGCTTCCG-1 | 186 | 0.017430846 | 2639.0 | CD14+ Monocytes |\n", + "| AAACCGTGTATGCG-1 | 157 | 0.012244898 | 980.0 | NK cells |" + ] + }, + { + "cell_type": "markdown", + "id": "1e3e9119", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pp.normalize_total**\n", + "\n", + "The task is to normalize the data so that each cell has the same total count, which is important for grouping similar cells effectively. We solved it by using a function that adjusts the counts for each cell and can even ignore highly expressed genes if needed, ensuring a fair comparison across all cells." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2199faf", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pp import normalize_total\n", + "result_4 = normalize_total(result_1, target_sum=1, inplace=True, copy=False)" + ] + }, + { + "cell_type": "markdown", + "id": "8a445c83", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "Executed successfully! No new variable obtained" + ] + }, + { + "cell_type": "markdown", + "id": "ce929625", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pp.neighbors**\n", + "\n", + "The task is to find the nearest neighbors in a dataset, which helps in understanding the relationships between different data points. We solved it by using the `scanpy.pp.neighbors` function, which calculates how closely related each data point is to others, allowing us to choose the number of neighbors and the method of measurement for these connections." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ba7106a8", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pp import neighbors\n", + "result_5 = neighbors(result_1, copy=False)" + ] + }, + { + "cell_type": "markdown", + "id": "4cec7f15", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "Executed successfully! No new variable obtained" + ] + }, + { + "cell_type": "markdown", + "id": "784ab512", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pl.umap**\n", + "\n", + "The task is to visualize clustering results in a UMAP (Uniform Manifold Approximation and Projection) format, which helps display the relationships between different data points. We solved it by using the `scanpy.pl.umap` function, specifying the data and the coloring options to represent different clusters or gene expressions on the scatter plot." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b44cecda", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pl import umap\n", + "result_6 = umap(result_1, color='louvain', legend_fontsize='medium', show=True)" + ] + }, + { + "cell_type": "markdown", + "id": "6c0480b8", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "Executed successfully! No new variable obtained" + ] + }, + { + "cell_type": "markdown", + "id": "6efcdfa9", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the obtained figure. Try to zoom in or out the figure." + ] + }, + { + "cell_type": "markdown", + "id": "64c16b7a", + "metadata": {}, + "source": [ + "![Image](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "75565021", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We interpret the obtained figure: The UMAP clustering reveals distinct spatial separation among various immune cell types, indicating potential functional diversity and interaction patterns within the dataset." + ] + }, + { + "cell_type": "markdown", + "id": "20d404ab", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.datasets.pbmc3k_processed**\n", + "\n", + "The task is to load a dataset that contains information about 3,000 immune cells for analysis. We solved it by using a specific function that provides this pre-processed dataset, making it ready for our clustering analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d23b6fbc", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.datasets import pbmc3k_processed\n", + "result_1 = pbmc3k_processed()" + ] + }, + { + "cell_type": "markdown", + "id": "57e2b1d6", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n", + " var: 'n_cells'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "4fc4859a", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "453d7bba", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain |\n", + "|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 781 | 0.030177759 | 2419.0 | CD4 T cells |\n", + "| AAACATTGAGCTAC-1 | 1352 | 0.037935957 | 4903.0 | B cells |\n", + "| AAACATTGATCAGC-1 | 1131 | 0.008897362 | 3147.0 | CD4 T cells |\n", + "| AAACCGTGCTTCCG-1 | 960 | 0.017430846 | 2639.0 | CD14+ Monocytes |\n", + "| AAACCGTGTATGCG-1 | 522 | 0.012244898 | 980.0 | NK cells |" + ] + }, + { + "cell_type": "markdown", + "id": "9a8d2425", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.tl.leiden**\n", + "\n", + "The task is to prepare data for better grouping of similar items, which in this case are cells, to improve analysis. We solved it by using the Leiden algorithm that organizes the cells into clusters based on their characteristics after first determining their relationships." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd8ac3b4", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.tl import leiden\n", + "result_2 = leiden(result_1, copy=False)" + ] + }, + { + "cell_type": "markdown", + "id": "593b999a", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain', 'leiden'\n", + " var: 'n_cells'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups', 'leiden'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "9e3dda49", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "991be4ac", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain | leiden |\n", + "|--|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 781 | 0.030177759 | 2419.0 | CD4 T cells | 0 |\n", + "| AAACATTGAGCTAC-1 | 1352 | 0.037935957 | 4903.0 | B cells | 2 |\n", + "| AAACATTGATCAGC-1 | 1131 | 0.008897362 | 3147.0 | CD4 T cells | 0 |\n", + "| AAACCGTGCTTCCG-1 | 960 | 0.017430846 | 2639.0 | CD14+ Monocytes | 1 |\n", + "| AAACCGTGTATGCG-1 | 522 | 0.012244898 | 980.0 | NK cells | 4 |" + ] + }, + { + "cell_type": "markdown", + "id": "a1828b7c", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.tl.leiden**\n", + "\n", + "The task is to identify clusters in processed data, which helps group similar items together. We solved it by using the `scanpy.tl.leiden` function, a tool that organizes data into clusters based on cell similarities, allowing us to specify various settings like how fine or coarse we want the clustering to be." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "939c5012", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.tl import leiden\n", + "result_3 = leiden(result_1, copy=False)" + ] + }, + { + "cell_type": "markdown", + "id": "fdbe09bb", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "Executed successfully! No new variable obtained" + ] + }, + { + "cell_type": "markdown", + "id": "0a8fdba0", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.tl.leiden**\n", + "\n", + "The task is to compute cluster centroids for further analysis of cell groups in a dataset. We solved it by using the `scanpy.tl.leiden` function, which groups cells into clusters based on their similarities, allowing us to identify and analyze the characteristics of each cluster." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1a6e2d1", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.tl import leiden\n", + "result_4 = leiden(result_1, copy=False)" + ] + }, + { + "cell_type": "markdown", + "id": "f2621c7c", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "Executed successfully! No new variable obtained" + ] + }, + { + "cell_type": "markdown", + "id": "187f58a2", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pl.scatter**\n", + "\n", + "The task is to create a scatter plot that helps visualize clusters in our data. We solved it by using a function called `scanpy.pl.scatter`, which allows us to specify the axes, colors, and other details to effectively display the data points and their relationships visually." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b48fa9bc", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pl import scatter\n", + "scatter(result_1, x='X_umap', y='X_tsne', color='percent_mito', basis='umap', show=True)" + ] + }, + { + "cell_type": "markdown", + "id": "4bd0f482", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "Executed successfully! No new variable obtained" + ] + }, + { + "cell_type": "markdown", + "id": "2447bd8a", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the obtained figure. Try to zoom in or out the figure." + ] + }, + { + "cell_type": "markdown", + "id": "bef87158", + "metadata": {}, + "source": [ + "![Image](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "4d205250", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We interpret the obtained figure: The scatter plot reveals distinct clusters in the PMBC dataset, with varying percentages of mitochondrial content, suggesting significant heterogeneity in cell populations based on mitochondrial gene expression." + ] + }, + { + "cell_type": "markdown", + "id": "fd269b95", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the obtained figure. Try to zoom in or out the figure." + ] + }, + { + "cell_type": "markdown", + "id": "e5e06053", + "metadata": {}, + "source": [ + "![Image](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "c4f5943c", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We interpret the obtained figure: The scatter plot reveals distinct clusters of cells with varying mitochondrial percentages, indicating heterogeneity in the PMBC dataset." + ] + }, + { + "cell_type": "markdown", + "id": "17542de7", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.datasets.pbmc3k_processed**\n", + "\n", + "The task is to load a pre-processed dataset of 3,000 PBMC (peripheral blood mononuclear cells) from a scientific source. We solved it by using the `scanpy.datasets.pbmc3k_processed()` function, which gives us a ready-to-use data matrix for analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46baf441", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.datasets import pbmc3k_processed\n", + "result_1 = pbmc3k_processed()" + ] + }, + { + "cell_type": "markdown", + "id": "040ffc55", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n", + " var: 'n_cells'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "50020950", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "05e1d872", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain |\n", + "|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 781 | 0.030177759 | 2419.0 | CD4 T cells |\n", + "| AAACATTGAGCTAC-1 | 1352 | 0.037935957 | 4903.0 | B cells |\n", + "| AAACATTGATCAGC-1 | 1131 | 0.008897362 | 3147.0 | CD4 T cells |\n", + "| AAACCGTGCTTCCG-1 | 960 | 0.017430846 | 2639.0 | CD14+ Monocytes |\n", + "| AAACCGTGTATGCG-1 | 522 | 0.012244898 | 980.0 | NK cells |" + ] + }, + { + "cell_type": "markdown", + "id": "408d595f", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pl.heatmap**\n", + "\n", + "The task is to visualize gene expression values using a heatmap, which helps us see patterns in gene activity across different conditions or groups. We solved it by using the `scanpy.pl.heatmap` function, which takes the gene expression data and specified genes to create a visual representation where colors indicate the level of expression." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cd7c003c", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pl import heatmap\n", + "heatmap(result_1, 'adata.var_names', 'louvain', log=True, standard_scale='var', show=True)" + ] + }, + { + "cell_type": "markdown", + "id": "9ac35c1d", + "metadata": {}, + "source": [ + "**Executed results [Fail]**\n", + "\n", + "KeyError: \"Could not find keys '['adata.var_names']' in columns of `adata.obs` or in adata.raw.var_names.\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43acd814", + "metadata": {}, + "outputs": [], + "source": [ + "import scanpy as sc\n", + "\n", + "heatmap_result = sc.pl.heatmap(result_1, var_names=result_1.var_names[:10], groupby='louvain', log=True, standard_scale='var', show=True)" + ] + }, + { + "cell_type": "markdown", + "id": "e0562daa", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "Executed successfully! No new variable obtained" + ] + }, + { + "cell_type": "markdown", + "id": "e6801e94", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the obtained figure. Try to zoom in or out the figure." + ] + }, + { + "cell_type": "markdown", + "id": "af0567df", + "metadata": {}, + "source": [ + "![Image](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "28352d13", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We interpret the obtained figure: The heatmap reveals distinct gene expression patterns among various immune cell types, highlighting specific markers that differentiate cell populations, particularly in CD4 T cells and CD14+ Monocytes." + ] + }, + { + "cell_type": "markdown", + "id": "213b79ef", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.datasets.pbmc3k_processed**\n", + "\n", + "The task is to load a specific dataset called the processed 3k PBMCs from 10x Genomics, which contains analyzed data for cell studies. We solved it by using the `scanpy.datasets.pbmc3k_processed()` function, which allows us to easily access this pre-processed data for further research." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8178f0f", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.datasets import pbmc3k_processed\n", + "result_1 = pbmc3k_processed()" + ] + }, + { + "cell_type": "markdown", + "id": "93d4cb3d", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n", + " var: 'n_cells'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "9130811f", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "61dcc375", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain |\n", + "|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 781 | 0.030177759 | 2419.0 | CD4 T cells |\n", + "| AAACATTGAGCTAC-1 | 1352 | 0.037935957 | 4903.0 | B cells |\n", + "| AAACATTGATCAGC-1 | 1131 | 0.008897362 | 3147.0 | CD4 T cells |\n", + "| AAACCGTGCTTCCG-1 | 960 | 0.017430846 | 2639.0 | CD14+ Monocytes |\n", + "| AAACCGTGTATGCG-1 | 522 | 0.012244898 | 980.0 | NK cells |" + ] + }, + { + "cell_type": "markdown", + "id": "bacabd39", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.datasets.pbmc3k_processed**\n", + "\n", + "The task is to load a pre-processed dataset of 3,000 blood cells from a specific biological study. We solved it by using the function `scanpy.datasets.pbmc3k_processed()`, which gives us an organized data table ready for analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c60123b", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.datasets import pbmc3k_processed\n", + "result_1 = pbmc3k_processed()" + ] + }, + { + "cell_type": "markdown", + "id": "57b5576c", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n", + " var: 'n_cells'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "15c482d4", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "9d464933", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain |\n", + "|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 781 | 0.030177759 | 2419.0 | CD4 T cells |\n", + "| AAACATTGAGCTAC-1 | 1352 | 0.037935957 | 4903.0 | B cells |\n", + "| AAACATTGATCAGC-1 | 1131 | 0.008897362 | 3147.0 | CD4 T cells |\n", + "| AAACCGTGCTTCCG-1 | 960 | 0.017430846 | 2639.0 | CD14+ Monocytes |\n", + "| AAACCGTGTATGCG-1 | 522 | 0.012244898 | 980.0 | NK cells |" + ] + }, + { + "cell_type": "markdown", + "id": "a997827e", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pp.filter_cells**\n", + "\n", + "The task is to filter out unwanted cells from a dataset based on certain criteria, such as the minimum number of genes they express or the number of counts they have. We solved it by using the `filter_cells` function from the Scanpy library, which helps us keep only the reliable cells that meet our specified thresholds, allowing for cleaner data analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e35f3e9", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pp import filter_cells\n", + "result_2 = filter_cells(result_1, min_genes=3, inplace=True, copy=False)" + ] + }, + { + "cell_type": "markdown", + "id": "2e24fd15", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n", + " var: 'n_cells'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "31ef4197", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "ae2aa852", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain |\n", + "|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 144 | 0.030177759 | 2419.0 | CD4 T cells |\n", + "| AAACATTGAGCTAC-1 | 341 | 0.037935957 | 4903.0 | B cells |\n", + "| AAACATTGATCAGC-1 | 217 | 0.008897362 | 3147.0 | CD4 T cells |\n", + "| AAACCGTGCTTCCG-1 | 186 | 0.017430846 | 2639.0 | CD14+ Monocytes |\n", + "| AAACCGTGTATGCG-1 | 157 | 0.012244898 | 980.0 | NK cells |" + ] + }, + { + "cell_type": "markdown", + "id": "03b4a117", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pp.normalize_total**\n", + "\n", + "The task is to normalize the data to ensure that the values across different samples are consistent. We solved it by using the `scanpy.pp.normalize_total` function, which adjusts the counts for each cell to a target sum, allowing us to either exclude highly expressed genes or include them based on set parameters for more accurate normalization." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "247529f3", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pp import normalize_total\n", + "result_3 = normalize_total(result_1, target_sum=1e6, copy=False, inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "c81f6f01", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "Executed successfully! No new variable obtained" + ] + }, + { + "cell_type": "markdown", + "id": "ec6d3817", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.tl.pca**\n", + "\n", + "The task is to reduce the complexity of our data by performing dimensionality reduction. We solved it by using a function called PCA (Principal Component Analysis) from the Scanpy library, which simplifies the data while preserving important information by transforming it into a smaller set of variables." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50933b0d", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.tl import pca\n", + "result_4 = pca(result_1, n_comps=50, copy=False)" + ] + }, + { + "cell_type": "markdown", + "id": "e6c6e70b", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n", + " var: 'n_cells'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "b4562b17", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "86da84cb", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain |\n", + "|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 144 | 0.030177759 | 2419.0 | CD4 T cells |\n", + "| AAACATTGAGCTAC-1 | 341 | 0.037935957 | 4903.0 | B cells |\n", + "| AAACATTGATCAGC-1 | 217 | 0.008897362 | 3147.0 | CD4 T cells |\n", + "| AAACCGTGCTTCCG-1 | 186 | 0.017430846 | 2639.0 | CD14+ Monocytes |\n", + "| AAACCGTGTATGCG-1 | 157 | 0.012244898 | 980.0 | NK cells |" + ] + }, + { + "cell_type": "markdown", + "id": "8bb6711c", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.pl.umap**\n", + "\n", + "The task is to create a visual representation of data using UMAP, which helps in understanding the relationships between different data points. We solved it by using the `scanpy.pl.umap` function, which generates a scatter plot based on the provided data and highlights various features, such as color coding based on gene expression or different categories." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15674eb5", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.pl import umap\n", + "result_5 = umap(result_1, color='louvain', layer='X_new', show=True)" + ] + }, + { + "cell_type": "markdown", + "id": "d9a797f7", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "Executed successfully! No new variable obtained" + ] + }, + { + "cell_type": "markdown", + "id": "3521a3c4", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the obtained figure. Try to zoom in or out the figure." + ] + }, + { + "cell_type": "markdown", + "id": "b42adb81", + "metadata": {}, + "source": [ + "![Image](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "id": "7059c113", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We interpret the obtained figure: The UMAP representation reveals distinct clustering of various immune cell types, indicating significant differences in their distributions and relationships in the dataset." + ] + }, + { + "cell_type": "markdown", + "id": "3645ae37", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.datasets.pbmc3k_processed**\n", + "\n", + "The task is to load a built-in dataset for clustering analysis. We solved it by using the `scanpy.datasets.pbmc3k_processed()` function, which provides an annotated data matrix of processed PBMCs (Peripheral Blood Mononuclear Cells) from 10x Genomics." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "166433ff", + "metadata": {}, + "outputs": [], + "source": [ + "from scanpy.datasets import pbmc3k_processed\n", + "result_1 = pbmc3k_processed()" + ] + }, + { + "cell_type": "markdown", + "id": "f74ece01", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n", + " obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n", + " var: 'n_cells'\n", + " uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n", + " obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n", + " varm: 'PCs'\n", + " obsp: 'distances', 'connectivities'" + ] + }, + { + "cell_type": "markdown", + "id": "48678672", + "metadata": {}, + "source": [ + "**Executed results [Success]**\n", + "\n", + "We visualize the first 5 rows of the table data" + ] + }, + { + "cell_type": "markdown", + "id": "f66c2107", + "metadata": {}, + "source": [ + "| index | n_genes | percent_mito | n_counts | louvain |\n", + "|--|--|--|--|--|\n", + "| AAACATACAACCAC-1 | 781 | 0.030177759 | 2419.0 | CD4 T cells |\n", + "| AAACATTGAGCTAC-1 | 1352 | 0.037935957 | 4903.0 | B cells |\n", + "| AAACATTGATCAGC-1 | 1131 | 0.008897362 | 3147.0 | CD4 T cells |\n", + "| AAACCGTGCTTCCG-1 | 960 | 0.017430846 | 2639.0 | CD14+ Monocytes |\n", + "| AAACCGTGTATGCG-1 | 522 | 0.012244898 | 980.0 | NK cells |" + ] + }, + { + "cell_type": "markdown", + "id": "f040572a", + "metadata": {}, + "source": [ + "**Predicted API: scanpy.get.obs_df**\n", + "\n", + "The task is to filter a dataset to focus on specific data points that are relevant to our interests. We solved it by using the `scanpy.get.obs_df` function, which allows us to select particular columns and values from our dataset, making it easier to analyze and visualize the information we need." + ] + } + ], + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/report/chatbot_ui_history_10-16.json b/src/report/chatbot_ui_history_10-16.json new file mode 100644 index 0000000..b1a3f50 --- /dev/null +++ b/src/report/chatbot_ui_history_10-16.json @@ -0,0 +1,9264 @@ +{ + "version": 4, + "history": [ + { + "id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "name": "New Conversation", + "method": { + "id": "No specified", + "name": "DFS without filter", + "method": "No specified", + "maxLength": 8000 + }, + "messages": [ + { + "role": "assistant", + "content": "", + "tools": [ + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "log-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "[Would you like to see some examples to learn how to interact with the bot?](https://github.com/batmen-lab/BioMANIA/tree/35da76f7d5cd40b99980654e84000e25ff167cb2/examples)", + "task_title": "Welcome to BioMANIA! How can I help?", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "hello", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": true, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-42", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-42", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-2", + "task": "Hello! How can I assist you today?", + "task_title": "Non API chitchat", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "perform clustering plase?", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-43", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-43", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-2", + "task": "Current and remaining tasks: \n → step 1: Load built-in dataset for clustering analysis.\n - step 2: Please filter the data based on quality metrics.\n - step 3: Could you normalize the data for better comparison?\n - step 4: Please run clustering algorithm on the processed data.\n - step 5: Can you create a scatter plot of clusters?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-3", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.datasets.ebi_expression_atlas : Load a dataset from the `EBI Single Cell Expression Atlas`__ Downloaded datasets are saved in the directory specified by :attr:`~scanpy. _settings. ScanpyConfig. datasetdir`. Similarity score: 0.30466875433921814\n - scanpy.tl.leiden : Cluster cells into subgroups [Traag18]_. Cluster cells using the Leiden algorithm [Traag18]_, an improved version of the Louvain algorithm [Blondel08]_. Similarity score: 0.30228912830352783\n - scanpy.datasets.pbmc3k_processed : Processed 3k PBMCs from 10x Genomics. Processed using the `basic tutorial `__. Similarity score: 0.2936146855354309", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-45", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-45", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-4", + "task": "The task is to load a built-in dataset that can be used for grouping similar data points together, which is important in clustering analysis. We solved it by using the function `scanpy.datasets.pbmc3k_processed()`, which provides a pre-processed collection of data from 3,000 blood cells for our analysis.", + "task_title": "Predicted API: scanpy.datasets.pbmc3k_processed", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-5", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-47", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-47", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-47", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-47", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-47", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-47", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-6", + "task": "Here are the task description with keywords highlighted as evidence: \nstep 1: Load built-in dataset for clustering analysis.", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-48", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-48", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-7", + "task": "from scanpy.datasets import pbmc3k_processed\nresult_1 = pbmc3k_processed()", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-8", + "task": "The task is to obtain a pre-processed dataset of 3,000 cells from human blood for analysis. We solved it by using the `pbmc3k_processed` function from the ScanPy library, which provides this dataset in a ready-to-use format. In the code, `from scanpy.datasets import pbmc3k_processed` imports the function, and `result_1 = pbmc3k_processed()` calls it to store the dataset in a variable named `result_1`.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-9", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-51", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-51", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-51", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-51", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-51", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-51", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-10", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-11", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n var: 'n_cells'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-12", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain\nAAACATACAACCAC-1,781,0.030177759,2419.0,CD4 T cells\nAAACATTGAGCTAC-1,1352,0.037935957,4903.0,B cells\nAAACATTGATCAGC-1,1131,0.008897362,3147.0,CD4 T cells\nAAACCGTGCTTCCG-1,960,0.017430846,2639.0,CD14+ Monocytes\nAAACCGTGTATGCG-1,522,0.012244898,980.0,NK cells", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-13", + "task": "Current and remaining tasks: \n → step 2: Please filter the data based on quality metrics.\n - step 3: Could you normalize the data for better comparison?\n - step 4: Please run clustering algorithm on the processed data.\n - step 5: Can you create a scatter plot of clusters?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-55", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-55", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-55", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-55", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-14", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pp.recipe_weinreb17 : Normalization and filtering as of [Weinreb17]_. Expects non-logarithmized data. Similarity score: 0.30615153908729553\n - scanpy.pp.calculate_qc_metrics : Calculate quality control metrics. Calculates a number of qc metrics for an AnnData object, see section `Returns` for specifics. Similarity score: 0.24488045275211334\n - scanpy.datasets.pbmc3k_processed : Processed 3k PBMCs from 10x Genomics. Processed using the `basic tutorial `__. Similarity score: 0.22966793179512024", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-56", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-56", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-15", + "task": "The task is to filter and assess data quality based on specific metrics. We solved it by using a function called `calculate_qc_metrics` from the Scanpy library, which analyzes the data, calculates various quality control measurements, and can update the results directly in the data structure we are working with.", + "task_title": "Predicted API: scanpy.pp.calculate_qc_metrics", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-16", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-61", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-61", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-61", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-61", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-61", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-61", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-17", + "task": "Here are the task description with keywords highlighted as evidence: \nPlease filter the data based on quality metrics with 'qc_vars' set as ['mito'].", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-62", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-62", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-18", + "task": "from scanpy.pp import calculate_qc_metrics\nresult_2 = calculate_qc_metrics(result_1, qc_vars=['mito'], inplace=True)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-19", + "task": "The task is to calculate quality control metrics for a dataset that helps assess the quality of single-cell RNA sequencing data. We solved it by using the `calculate_qc_metrics` function from the Scanpy library, specifying that we want to track mitochondrial genes with `qc_vars=['mito']`, and we opted to store the results directly in our dataset with `inplace=True`. This means that the function will analyze the data and update it with new quality metrics that will help us understand how many genes are expressed and their overall counts in the cells.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-20", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-65", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-65", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-65", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-65", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-65", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-65", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-21", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-22", + "task": "KeyError: 'mito'\n\nThe above exception was the direct cause of the following exception:\n\nTraceback (most recent call last):\n File \"/home/z6dong/BioChat/refer/src/BioMANIA/src/inference/execution_UI.py\", line 524, in execute_api_call\n exec(api_call_code, locals(), globals())\n File \"\", line 1, in \n File \"/home/z6dong/anaconda3/envs/biomania_39/lib/python3.9/site-packages/scanpy/preprocessing/_qc.py\", line 316, in calculate_qc_metrics\n obs_metrics = describe_obs(\n File \"/home/z6dong/anaconda3/envs/biomania_39/lib/python3.9/site-packages/scanpy/preprocessing/_qc.py\", line 129, in describe_obs\n X[:, adata.var[qc_var].values].sum(axis=1)\n File \"/home/z6dong/anaconda3/envs/biomania_39/lib/python3.9/site-packages/pandas/core/frame.py\", line 3896, in __getitem__\n indexer = self.columns.get_loc(key)\n File \"/home/z6dong/anaconda3/envs/biomania_39/lib/python3.9/site-packages/pandas/core/indexes/base.py\", line 3797, in get_loc\n raise KeyError(key) from err\nKeyError: 'mito'", + "task_title": "Executed results [Fail]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-23", + "task": "The KeyError for 'mito' indicates that the quality metric variable for mitochondria has not been defined in the var attribute of the AnnData object. To resolve this, I will create a boolean variable for mitochondrial genes in the var attribute before calling the calculate_qc_metrics function.", + "task_title": "Error Analysis, retry count: 1/5", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "code-24", + "task": "result_1.var['mito'] = result_1.var_names.str.startswith('MT-')\nresult_2 = calculate_qc_metrics(result_1, qc_vars=['mito'], inplace=True)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-25", + "task": "The task is to assess the quality of gene expression data by calculating various metrics related to the data's integrity and characteristics. We solved it by using a function that checks for specific genes (in this case, mitochondrial genes, identified by names starting with \"MT-\") and calculates quality control metrics, updating the data directly for easy access. This involves setting the `qc_vars` parameter to include mitochondrial genes for more focused analysis, and using `inplace=True` so the results are stored directly in our data without needing a separate output.", + "task_title": "Code explanation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-70", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-70", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-27", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain', 'n_genes_by_counts', 'log1p_n_genes_by_counts', 'total_counts', 'log1p_total_counts', 'pct_counts_in_top_50_genes', 'pct_counts_in_top_100_genes', 'pct_counts_in_top_200_genes', 'pct_counts_in_top_500_genes', 'total_counts_mito', 'log1p_total_counts_mito', 'pct_counts_mito'\n var: 'n_cells', 'mito', 'n_cells_by_counts', 'mean_counts', 'log1p_mean_counts', 'pct_dropout_by_counts', 'total_counts', 'log1p_total_counts'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-28", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain,n_genes_by_counts,log1p_n_genes_by_counts,total_counts,log1p_total_counts,pct_counts_in_top_50_genes,pct_counts_in_top_100_genes,pct_counts_in_top_200_genes,pct_counts_in_top_500_genes,total_counts_mito,log1p_total_counts_mito,pct_counts_mito\nAAACATACAACCAC-1,781,0.030177759,2419.0,CD4 T cells,1838,7.516977224604321,-54.403603,,-394.0494943827394,-591.2966152833859,-652.8546350200518,-615.3194478198695,0.0,0.0,-0.0\nAAACATTGAGCTAC-1,1352,0.037935957,4903.0,B cells,1838,7.516977224604321,-74.253,,-274.4154552858986,-425.13938623511416,-584.6912336607829,-594.6293800075192,0.0,0.0,-0.0\nAAACATTGATCAGC-1,1131,0.008897362,3147.0,CD4 T cells,1838,7.516977224604321,14.642954,2.7500205,1459.7248839897748,2207.40727811518,2908.333210674569,2803.6175781949623,0.0,0.0,0.0\nAAACCGTGCTTCCG-1,960,0.017430846,2639.0,CD14+ Monocytes,1838,7.516977224604321,25.272524,3.2685237,780.8842828960819,1223.1575037163923,1638.7717176974238,1565.8289183288766,0.0,0.0,0.0\nAAACCGTGTATGCG-1,522,0.012244898,980.0,NK cells,1838,7.516977224604321,6.548219,2.0213118,3784.372483863411,5127.23927008491,5156.42582645063,4886.076713670838,0.0,0.0,0.0", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-29", + "task": "Current and remaining tasks: \n → step 3: Could you normalize the data for better comparison?\n - step 4: Please run clustering algorithm on the processed data.\n - step 5: Can you create a scatter plot of clusters?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-73", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-73", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-73", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-73", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-30", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pp.recipe_weinreb17 : Normalization and filtering as of [Weinreb17]_. Expects non-logarithmized data. Similarity score: 0.30862319469451904\n - scanpy.pp.normalize_total : Normalize counts per cell. Normalize each cell by total counts over all genes, so that every cell has the same total count after normalization. Similarity score: 0.3036174178123474\n - scanpy.pp.recipe_seurat : Normalization and filtering as of Seurat [Satija15]_. This uses a particular preprocessing. Similarity score: 0.29709678888320923", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-74", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-74", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-31", + "task": "The task is to normalize the data so that we can compare different cells fairly. We solved it by using a function that adjusts the total counts in each cell, making them equal, optionally excluding genes that are very highly expressed to avoid skewing the results.", + "task_title": "Predicted API: scanpy.pp.normalize_total", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-32", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-76", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-76", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-76", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-76", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-76", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-76", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-33", + "task": "Here are the task description with keywords highlighted as evidence: \nCould you normalize the data with 'target_sum' set as '1e6' and 'max_fraction' set as '0.05'?", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-77", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-77", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-34", + "task": "from scanpy.pp import normalize_total\nresult_3 = normalize_total(result_1, target_sum=1000000.0, layers='target_sum=1e6, max_fraction=0.05', inplace=True, copy=False)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-35", + "task": "The task is to normalize data representing gene expression across different cells so that they can be compared more easily. We solved it by using the `normalize_total` function from the Scanpy library, setting a target total count for each cell to 1,000,000 and allowing for some genes that are highly expressed to be excluded from the normalization process to avoid skewing the results. In this case, we aimed for a consistent scale across the cells (target_sum=1e6) while ensuring that genes with excessive counts (max_fraction=0.05) didn’t disproportionately influence the outcome, and we updated the original dataset directly (inplace=True).", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-36", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-80", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-80", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-80", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-80", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-80", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-80", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-37", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-38", + "task": "ValueError: `layers` needs to be a list of strings or 'all', not 'target_sum=1e6, max_fraction=0.05'", + "task_title": "Executed results [Fail]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-39", + "task": "The error occurred because the parameters 'layers' were incorrectly formatted as a string instead of being passed as a list of strings. To correct this, I will set 'target_sum' to 1e6, 'max_fraction' to 0.05, and ensure that 'layers' parameter is not included, as it is not necessary for basic normalization.", + "task_title": "Error Analysis, retry count: 1/5", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "code-40", + "task": "result_3 = normalize_total(result_1, target_sum=1e6, max_fraction=0.05, inplace=True, copy=False)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-41", + "task": "The task is to normalize the data for each cell in a dataset so that every cell has the same total count, which helps in making comparisons more meaningful. We solved it by using the `normalize_total` function with parameters set to ensure each cell's total count equals 1 million, excluding any highly expressed genes that might skew the results. Specifically, `target_sum=1e6` ensures the total count per cell is standardized, while `max_fraction=0.05` restricts the influence of overly dominant genes in this calculation, and `inplace=True` means we directly update the original data without creating a separate copy.", + "task_title": "Code explanation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-85", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-85", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-43", + "task": "Executed successfully! No new variable obtained", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-44", + "task": "Current and remaining tasks: \n → step 4: Please run clustering algorithm on the processed data.\n - step 5: Can you create a scatter plot of clusters?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-87", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-87", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-87", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-87", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-45", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.tl.leiden : Cluster cells into subgroups [Traag18]_. Cluster cells using the Leiden algorithm [Traag18]_, an improved version of the Louvain algorithm [Blondel08]_. Similarity score: 0.3513314127922058\n - scanpy.datasets.pbmc3k_processed : Processed 3k PBMCs from 10x Genomics. Processed using the `basic tutorial `__. Similarity score: 0.3252095580101013\n - scanpy.tl.dendrogram : Computes a hierarchical clustering for the given `groupby` categories. By default, the PCA representation is used unless `. X` has less than 50 variables. Similarity score: 0.27606451511383057", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-88", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-88", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-46", + "task": "The task is to group similar cells into clusters using a clustering algorithm after processing the data. We solved it by using the Leiden algorithm through a specific function that analyzes the cell data and creates subgroups based on their similarities.", + "task_title": "Predicted API: scanpy.tl.leiden", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-47", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-90", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-90", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-90", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-90", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-90", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-90", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-48", + "task": "Here are the task description with keywords highlighted as evidence: \nPlease run the Leiden clustering algorithm on the processed data with 'resolution' set as 1 and 'key_added' set as 'louvain'.", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-91", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-91", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-49", + "task": "from scanpy.tl import leiden\nresult_4 = leiden(result_1, key_added='louvain', copy=False)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-50", + "task": "The task is to group similar cells into clusters using a method called the Leiden algorithm, which helps identify cell subgroups from single-cell data. We solved it by calling the `leiden` function from the Scanpy library, where we specified `key_added='louvain'` to label the clusters accordingly and set `copy=False` to modify the existing data rather than create a duplicate. This means we are organizing the cells based on their similarities, and we'll be able to see the cluster each cell belongs to right in our original data set.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-51", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-94", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-94", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-94", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-94", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-94", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-94", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-52", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-53", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain', 'n_genes_by_counts', 'log1p_n_genes_by_counts', 'total_counts', 'log1p_total_counts', 'pct_counts_in_top_50_genes', 'pct_counts_in_top_100_genes', 'pct_counts_in_top_200_genes', 'pct_counts_in_top_500_genes', 'total_counts_mito', 'log1p_total_counts_mito', 'pct_counts_mito'\n var: 'n_cells', 'mito', 'n_cells_by_counts', 'mean_counts', 'log1p_mean_counts', 'pct_dropout_by_counts', 'total_counts', 'log1p_total_counts'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-54", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain,n_genes_by_counts,log1p_n_genes_by_counts,total_counts,log1p_total_counts,pct_counts_in_top_50_genes,pct_counts_in_top_100_genes,pct_counts_in_top_200_genes,pct_counts_in_top_500_genes,total_counts_mito,log1p_total_counts_mito,pct_counts_mito\nAAACATACAACCAC-1,781,0.030177759,2419.0,0,1838,7.516977224604321,-54.403603,,-394.0494943827394,-591.2966152833859,-652.8546350200518,-615.3194478198695,0.0,0.0,-0.0\nAAACATTGAGCTAC-1,1352,0.037935957,4903.0,2,1838,7.516977224604321,-74.253,,-274.4154552858986,-425.13938623511416,-584.6912336607829,-594.6293800075192,0.0,0.0,-0.0\nAAACATTGATCAGC-1,1131,0.008897362,3147.0,0,1838,7.516977224604321,14.642954,2.7500205,1459.7248839897748,2207.40727811518,2908.333210674569,2803.6175781949623,0.0,0.0,0.0\nAAACCGTGCTTCCG-1,960,0.017430846,2639.0,1,1838,7.516977224604321,25.272524,3.2685237,780.8842828960819,1223.1575037163923,1638.7717176974238,1565.8289183288766,0.0,0.0,0.0\nAAACCGTGTATGCG-1,522,0.012244898,980.0,4,1838,7.516977224604321,6.548219,2.0213118,3784.372483863411,5127.23927008491,5156.42582645063,4886.076713670838,0.0,0.0,0.0", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-55", + "task": "Current and remaining tasks: \n → step 5: Can you create a scatter plot of clusters?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-98", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-98", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-98", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-98", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-56", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pl.draw_graph : Scatter plot in graph-drawing basis. Similarity score: 0.39846912026405334\n - scanpy.tl.leiden : Cluster cells into subgroups [Traag18]_. Cluster cells using the Leiden algorithm [Traag18]_, an improved version of the Louvain algorithm [Blondel08]_. Similarity score: 0.396539568901062\n - scanpy.pl.embedding : Scatter plot for user specified embedding basis (e. g. umap, pca, etc) Similarity score: 0.3804605007171631", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-99", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-99", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-57", + "task": "The task is to create a scatter plot that visualizes different clusters in the data. We solved it by using the `scanpy.pl.draw_graph` function, which allows us to specify colors for annotations and plot styles to effectively represent the clusters.", + "task_title": "Predicted API: scanpy.pl.draw_graph", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-58", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-101", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-101", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-101", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-101", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-101", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-101", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-59", + "task": "Here are the task description with keywords highlighted as evidence: \nCan you create a scatter plot of clusters using the 'louvain' key for coloring?", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-102", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-102", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-60", + "task": "from scanpy.pl import draw_graph\nresult_5 = draw_graph(result_1, color='louvain', show=True)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-61", + "task": "The task is to visualize relationships between different data points in a clear and colorful way using a scatter plot. We solved it by using the `draw_graph` function from the Scanpy library, specifying that we want the points colored based on the 'louvain' clustering, which groups similar data points together. By setting `show=True`, we ensured that the generated plot is displayed immediately for us to review.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-62", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-105", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-105", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-105", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-105", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-105", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-105", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-63", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-64", + "task": "Executed successfully! No new variable obtained", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-65", + "task": "We visualize the obtained figure. Try to zoom in or out the figure.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "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", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-66", + "task": "We interpret the obtained figure: The scatter plot indicates distinct clusters corresponding to different communities, with several clearly separated groupings represented by various colors, suggesting the presence of diverse subpopulations within the data.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-67", + "task": "We will start another round. Could you re-enter your inquiry?", + "task_title": "Start another round", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "11ff04d7-b4e5-48f9-943c-1bdfb331a2b3", + "mode": "T" + } + ], + "top_k": 1, + "folderId": null, + "Lib": "scanpy", + "files": [], + "new_lib_github_url": "", + "new_lib_doc_url": "", + "api_html": "", + "lib_alias": "", + "conversation_started": true, + "session_id": "", + "mode": "T" + }, + { + "id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "name": "New Conversation", + "method": { + "id": "No specified", + "name": "DFS without filter", + "method": "No specified", + "maxLength": 8000 + }, + "messages": [ + { + "role": "assistant", + "content": "", + "tools": [ + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "log-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "[Would you like to see some examples to learn how to interact with the bot?](https://github.com/batmen-lab/BioMANIA/tree/35da76f7d5cd40b99980654e84000e25ff167cb2/examples)", + "task_title": "Welcome to BioMANIA! How can I help?", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "Could you perform clustering please?", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": true, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-110", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-110", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-2", + "task": "No data are uploaded! Would you ensure to go on?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn.", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-111", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-111", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-111", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-111", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-111", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-111", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-111", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-111", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-111", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-111", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-3", + "task": "Current and remaining tasks: \n → step 1: Please load built-in dataset for clustering analysis.\n - step 2: Could you filter the data to remove unwanted cells?\n - step 3: Please normalize the data for effective clustering.\n - step 4: Could you compute the nearest neighbors of the data?\n - step 5: Can you draw clustering result in UMAP basis?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-4", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.datasets.ebi_expression_atlas : Load a dataset from the `EBI Single Cell Expression Atlas`__ Downloaded datasets are saved in the directory specified by :attr:`~scanpy. _settings. ScanpyConfig. datasetdir`. Similarity score: 0.33406415581703186\n - scanpy.datasets.pbmc3k_processed : Processed 3k PBMCs from 10x Genomics. Processed using the `basic tutorial `__. Similarity score: 0.3238675594329834\n - scanpy.tl.leiden : Cluster cells into subgroups [Traag18]_. Cluster cells using the Leiden algorithm [Traag18]_, an improved version of the Louvain algorithm [Blondel08]_. Similarity score: 0.3135885000228882", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-113", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-113", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-5", + "task": "The task is to load a ready-to-use dataset that we can analyze for clustering. We solved it by using the function `scanpy.datasets.pbmc3k_processed()`, which gives us a pre-processed data matrix of specific blood cells for our analysis.", + "task_title": "Predicted API: scanpy.datasets.pbmc3k_processed", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-6", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-115", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-115", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-115", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-115", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-115", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-115", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-7", + "task": "Here are the task description with keywords highlighted as evidence: \nstep 1: Please load built-in dataset for clustering analysis.", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-116", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-116", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-8", + "task": "from scanpy.datasets import pbmc3k_processed\nresult_1 = pbmc3k_processed()", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-9", + "task": "The task is to access a pre-processed dataset of a specific type of blood cells called PBMCs, which comes from an experiment involving 10x Genomics. We solved it by using a function `pbmc3k_processed` from the Scanpy library, which retrieves this data when we call it in our code. In the code, `from scanpy.datasets import pbmc3k_processed` allows us to use this function, and `result_1 = pbmc3k_processed()` stores the dataset in a variable named `result_1` for further analysis.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-10", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-119", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-119", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-119", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-119", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-119", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-119", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-11", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-12", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n var: 'n_cells'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-13", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain\nAAACATACAACCAC-1,781,0.030177759,2419.0,CD4 T cells\nAAACATTGAGCTAC-1,1352,0.037935957,4903.0,B cells\nAAACATTGATCAGC-1,1131,0.008897362,3147.0,CD4 T cells\nAAACCGTGCTTCCG-1,960,0.017430846,2639.0,CD14+ Monocytes\nAAACCGTGTATGCG-1,522,0.012244898,980.0,NK cells", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-14", + "task": "Current and remaining tasks: \n → step 2: Could you filter the data to remove unwanted cells?\n - step 3: Please normalize the data for effective clustering.\n - step 4: Could you compute the nearest neighbors of the data?\n - step 5: Can you draw clustering result in UMAP basis?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-123", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-123", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-123", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-15", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pp.filter_cells : Filter cell outliers based on counts and numbers of genes expressed. For instance, only keep cells with at least `min_counts` counts or `min_genes` genes expressed. Similarity score: 0.46103572845458984\n - scanpy.pp.filter_genes : Filter genes based on number of cells or counts. Keep genes that have at least `min_counts` counts or are expressed in at least `min_cells` cells or have at most `max_counts` counts or are expressed in at most `max_cells` cells. Similarity score: 0.3167329728603363\n - scanpy.datasets.ebi_expression_atlas : Load a dataset from the `EBI Single Cell Expression Atlas`__ Downloaded datasets are saved in the directory specified by :attr:`~scanpy. _settings. ScanpyConfig. datasetdir`. Similarity score: 0.25380396842956543", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-124", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-124", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-16", + "task": "The task is to filter out unwanted cells from a dataset based on specific criteria like the minimum number of genes expressed or the number of counts. We solved it by using the `scanpy.pp.filter_cells` function, which allows us to specify thresholds to keep only the reliable cells, ensuring our data is more accurate for analysis.", + "task_title": "Predicted API: scanpy.pp.filter_cells", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-17", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-157", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-157", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-157", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-157", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-157", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-157", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-18", + "task": "Here are the task description with keywords highlighted as evidence: \nCould you filter the data to remove unwanted cells by setting 'min_genes' to 3?", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-158", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-158", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-19", + "task": "from scanpy.pp import filter_cells\nresult_3 = filter_cells(result_1, min_genes=3, inplace=True, copy=False)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-20", + "task": "The task is to filter out specific cells in a dataset based on the number of genes they express. We solved it by using the `filter_cells` function from the Scanpy library, setting the parameter `min_genes=3` to ensure we only keep cells that express at least three genes, and choosing `inplace=True` to apply the changes directly to the original dataset without creating a copy. This way, we can clean up our data by removing unreliable cells, leading to more accurate analysis results.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-21", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-187", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-187", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-187", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-187", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-187", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-187", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-22", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-23", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n var: 'n_cells'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-24", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain\nAAACATACAACCAC-1,144,0.030177759,2419.0,CD4 T cells\nAAACATTGAGCTAC-1,341,0.037935957,4903.0,B cells\nAAACATTGATCAGC-1,217,0.008897362,3147.0,CD4 T cells\nAAACCGTGCTTCCG-1,186,0.017430846,2639.0,CD14+ Monocytes\nAAACCGTGTATGCG-1,157,0.012244898,980.0,NK cells", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-25", + "task": "Current and remaining tasks: \n → step 3: Please normalize the data for effective clustering.\n - step 4: Could you compute the nearest neighbors of the data?\n - step 5: Can you draw clustering result in UMAP basis?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-191", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-191", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-191", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-26", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.tl.leiden : Cluster cells into subgroups [Traag18]_. Cluster cells using the Leiden algorithm [Traag18]_, an improved version of the Louvain algorithm [Blondel08]_. Similarity score: 0.39260077476501465\n - scanpy.pp.normalize_total : Normalize counts per cell. Normalize each cell by total counts over all genes, so that every cell has the same total count after normalization. Similarity score: 0.3002643585205078\n - scanpy.tl.louvain : Cluster cells into subgroups [Blondel08]_ [Levine15]_ [Traag17]_. Cluster cells using the Louvain algorithm [Blondel08]_ in the implementation of [Traag17]_. Similarity score: 0.29055702686309814", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-192", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-192", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-27", + "task": "The task is to normalize the data so that each cell has the same total count, which is important for grouping similar cells effectively. We solved it by using a function that adjusts the counts for each cell and can even ignore highly expressed genes if needed, ensuring a fair comparison across all cells.", + "task_title": "Predicted API: scanpy.pp.normalize_total", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-28", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-194", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-194", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-194", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-194", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-194", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-194", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-29", + "task": "Here are the task description with keywords highlighted as evidence: \nPlease normalize the data with 'target_sum' set as '1' and 'max_fraction' as '0.05' for effective clustering.", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-195", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-195", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-30", + "task": "from scanpy.pp import normalize_total\nresult_4 = normalize_total(result_1, target_sum=1, inplace=True, copy=False)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-31", + "task": "The task is to normalize the gene expression data for cells so that each cell's total count is the same, allowing for fair comparison. We solved it by using the `normalize_total` function from the Scanpy library, setting `target_sum=1` so that each cell's total counts would add up to 1, and choosing `inplace=True` to update the original data directly instead of creating a copy. This normalization helps to mitigate the influence of highly expressed genes, ensuring that the overall analysis focuses on meaningful differences in gene expression across cells without being skewed by a few very highly expressed genes.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-32", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-198", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-198", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-198", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-198", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-198", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-198", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-33", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-34", + "task": "Executed successfully! No new variable obtained", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-35", + "task": "Current and remaining tasks: \n → step 4: Could you compute the nearest neighbors of the data?\n - step 5: Can you draw clustering result in UMAP basis?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-201", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-201", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-201", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-201", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-36", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pp.neighbors : Compute a neighborhood graph of observations [McInnes18]_. The neighbor search efficiency of this heavily relies on UMAP [McInnes18]_, which also provides a method for estimating connectivities of data points - the connectivity of the manifold (`method=='umap'`). Similarity score: 0.6537889242172241\n - scanpy.Neighbors.compute_neighbors : Compute distances and connectivities of neighbors. Similarity score: 0.547394871711731\n - scanpy.Neighbors.compute_eigen : Compute eigen decomposition of transition matrix. Similarity score: 0.297913134098053", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-202", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-202", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-37", + "task": "The task is to find the nearest neighbors in a dataset, which helps in understanding the relationships between different data points. We solved it by using the `scanpy.pp.neighbors` function, which calculates how closely related each data point is to others, allowing us to choose the number of neighbors and the method of measurement for these connections.", + "task_title": "Predicted API: scanpy.pp.neighbors", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-38", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-204", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-204", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-204", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-204", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-204", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-204", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-39", + "task": "Here are the task description with keywords highlighted as evidence: \nCould you compute the nearest neighbors of the data with 'n_neighbors' set as 15?", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-205", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-205", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-40", + "task": "from scanpy.pp import neighbors\nresult_5 = neighbors(result_1, copy=False)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-41", + "task": "The task is to create a neighborhood graph for a dataset, which helps understand how closely related the data points are to each other. We solved it by using the `neighbors` function from the Scanpy library, which takes our dataset (`result_1`) as input and processes it to find neighboring points without making a copy of the data. In the function, we used the default parameters, meaning it will consider the standard settings for the number of neighbors and distance calculations, allowing the function to automatically determine the best way to group data points based on their proximity.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-42", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-208", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-208", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-208", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-208", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-208", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-208", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-43", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-43", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-43", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-43", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-43", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-43", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-43", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-43", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-44", + "task": "Executed successfully! No new variable obtained", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-45", + "task": "Current and remaining tasks: \n → step 5: Can you draw clustering result in UMAP basis?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-218", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-218", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-218", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-218", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-46", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pl.umap : Scatter plot in UMAP basis. Similarity score: 0.5102192163467407\n - scanpy.tl.umap : Embed the neighborhood graph using UMAP [McInnes18]_. UMAP (Uniform Manifold Approximation and Projection) is a manifold learning technique suitable for visualizing high-dimensional data. Similarity score: 0.44939881563186646\n - scanpy.pl.draw_graph : Scatter plot in graph-drawing basis. Similarity score: 0.36336231231689453", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-219", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-219", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-47", + "task": "The task is to visualize clustering results in a UMAP (Uniform Manifold Approximation and Projection) format, which helps display the relationships between different data points. We solved it by using the `scanpy.pl.umap` function, specifying the data and the coloring options to represent different clusters or gene expressions on the scatter plot.", + "task_title": "Predicted API: scanpy.pl.umap", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-48", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-221", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-221", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-221", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-221", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-221", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-221", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-49", + "task": "Here are the task description with keywords highlighted as evidence: \nCan you draw clustering result in UMAP basis using 'color' set as 'louvain'?", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-222", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-222", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-50", + "task": "from scanpy.pl import umap\nresult_6 = umap(result_1, color='louvain', legend_fontsize='medium', show=True)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-51", + "task": "The task is to create a visual representation (scatter plot) of data points using the UMAP technique, highlighting different groups based on a specific variable called 'louvain'. We solved it by using the `umap` function from the Scanpy library, specifying the color parameter to indicate that we want the points colored according to the 'louvain' grouping, setting the legend font size to 'medium' for better readability, and choosing to display the plot immediately. This allows viewers to easily see how the data points cluster together based on the specified category.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-52", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-225", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-225", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-225", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-225", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-225", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-225", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-53", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-54", + "task": "Executed successfully! No new variable obtained", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-55", + "task": "We visualize the obtained figure. Try to zoom in or out the figure.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "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", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-56", + "task": "We interpret the obtained figure: The UMAP clustering reveals distinct spatial separation among various immune cell types, indicating potential functional diversity and interaction patterns within the dataset.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-57", + "task": "We will start another round. Could you re-enter your inquiry?", + "task_title": "Start another round", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "61c57e36-d535-485e-8524-a8037d2c0f9e", + "mode": "T" + } + ], + "top_k": 1, + "folderId": null, + "Lib": "scanpy", + "files": [], + "new_lib_github_url": "", + "new_lib_doc_url": "", + "api_html": "", + "lib_alias": "", + "conversation_started": true, + "session_id": "", + "mode": "T" + }, + { + "id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "name": "新的聊天", + "method": { + "id": "No specified", + "name": "DFS without filter", + "method": "No specified", + "maxLength": 8000 + }, + "messages": [ + { + "role": "assistant", + "content": "", + "tools": [ + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "log-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "[Would you like to see some examples to learn how to interact with the bot?](https://github.com/batmen-lab/BioMANIA/tree/35da76f7d5cd40b99980654e84000e25ff167cb2/examples)", + "task_title": "Welcome to BioMANIA! How can I help?", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "Could you perform clustering please?", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": true, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-231", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-231", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-2", + "task": "No data are uploaded! Would you ensure to go on?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn.", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-232", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-232", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-232", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-232", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-232", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-232", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-232", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-232", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-232", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-232", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-3", + "task": "Current and remaining tasks: \n → step 1: Load built-in dataset for clustering analysis.\n - step 2: Please preprocess the data for better clustering results.\n - step 3: Could you identify clusters in the processed data?\n - step 4: Please compute cluster centroids for further analysis.\n - step 5: Can you create a scatter plot to visualize clusters?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-4", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.datasets.ebi_expression_atlas : Load a dataset from the `EBI Single Cell Expression Atlas`__ Downloaded datasets are saved in the directory specified by :attr:`~scanpy. _settings. ScanpyConfig. datasetdir`. Similarity score: 0.30466875433921814\n - scanpy.tl.leiden : Cluster cells into subgroups [Traag18]_. Cluster cells using the Leiden algorithm [Traag18]_, an improved version of the Louvain algorithm [Blondel08]_. Similarity score: 0.30228912830352783\n - scanpy.datasets.pbmc3k_processed : Processed 3k PBMCs from 10x Genomics. Processed using the `basic tutorial `__. Similarity score: 0.2936146855354309", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-234", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-234", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-5", + "task": "The task is to load a dataset that contains information about 3,000 immune cells for analysis. We solved it by using a specific function that provides this pre-processed dataset, making it ready for our clustering analysis.", + "task_title": "Predicted API: scanpy.datasets.pbmc3k_processed", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-6", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-236", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-236", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-236", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-236", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-236", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-236", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-7", + "task": "Here are the task description with keywords highlighted as evidence: \nstep 1: Load built-in dataset for clustering analysis.", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-237", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-237", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-8", + "task": "from scanpy.datasets import pbmc3k_processed\nresult_1 = pbmc3k_processed()", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-9", + "task": "The task is to retrieve a specific dataset that contains information about 3,000 blood cells processed using advanced techniques. We solved it by using a function called `pbmc3k_processed` from a library called Scanpy, which automatically prepares the data for us. In the generated code, `from scanpy.datasets import pbmc3k_processed` brings the function into our workspace, and `result_1 = pbmc3k_processed()` actually fetches the data and stores it in a variable named `result_1` for further use.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-10", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-240", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-240", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-240", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-240", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-240", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-240", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-11", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-12", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n var: 'n_cells'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-13", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain\nAAACATACAACCAC-1,781,0.030177759,2419.0,CD4 T cells\nAAACATTGAGCTAC-1,1352,0.037935957,4903.0,B cells\nAAACATTGATCAGC-1,1131,0.008897362,3147.0,CD4 T cells\nAAACCGTGCTTCCG-1,960,0.017430846,2639.0,CD14+ Monocytes\nAAACCGTGTATGCG-1,522,0.012244898,980.0,NK cells", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-14", + "task": "Current and remaining tasks: \n → step 2: Please preprocess the data for better clustering results.\n - step 3: Could you identify clusters in the processed data?\n - step 4: Please compute cluster centroids for further analysis.\n - step 5: Can you create a scatter plot to visualize clusters?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-244", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-244", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-244", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-244", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-15", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.tl.leiden : Cluster cells into subgroups [Traag18]_. Cluster cells using the Leiden algorithm [Traag18]_, an improved version of the Louvain algorithm [Blondel08]_. Similarity score: 0.39240607619285583\n - scanpy.tl.louvain : Cluster cells into subgroups [Blondel08]_ [Levine15]_ [Traag17]_. Cluster cells using the Louvain algorithm [Blondel08]_ in the implementation of [Traag17]_. Similarity score: 0.2854893207550049\n - scanpy.tl.dendrogram : Computes a hierarchical clustering for the given `groupby` categories. By default, the PCA representation is used unless `. X` has less than 50 variables. Similarity score: 0.282725065946579", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-245", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-245", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-16", + "task": "The task is to prepare data for better grouping of similar items, which in this case are cells, to improve analysis. We solved it by using the Leiden algorithm that organizes the cells into clusters based on their characteristics after first determining their relationships.", + "task_title": "Predicted API: scanpy.tl.leiden", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-17", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-247", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-247", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-247", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-247", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-247", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-247", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-18", + "task": "Here are the task description with keywords highlighted as evidence: \nPlease preprocess the data for better clustering results with 'resolution' set as 1 and 'random_state' set as 0.", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-248", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-248", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-19", + "task": "from scanpy.tl import leiden\nresult_2 = leiden(result_1, copy=False)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-20", + "task": "The task is to group cells into different clusters to better understand their characteristics using a method called the Leiden algorithm. We solved it by using the `leiden` function from the Scanpy library, which analyzes our cell data (denoted as `result_1`) without making a copy of it. In this function, the `copy=False` parameter allows us to modify our data directly, while other options can control details like how finely we want to define our clusters and the randomness in the clustering process.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-21", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-252", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-252", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-252", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-252", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-252", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-252", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-23", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-24", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain', 'leiden'\n var: 'n_cells'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups', 'leiden'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-25", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain,leiden\nAAACATACAACCAC-1,781,0.030177759,2419.0,CD4 T cells,0\nAAACATTGAGCTAC-1,1352,0.037935957,4903.0,B cells,2\nAAACATTGATCAGC-1,1131,0.008897362,3147.0,CD4 T cells,0\nAAACCGTGCTTCCG-1,960,0.017430846,2639.0,CD14+ Monocytes,1\nAAACCGTGTATGCG-1,522,0.012244898,980.0,NK cells,4", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-26", + "task": "Current and remaining tasks: \n → step 3: Could you identify clusters in the processed data?\n - step 4: Please compute cluster centroids for further analysis.\n - step 5: Can you create a scatter plot to visualize clusters?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-256", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-256", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-256", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-256", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-27", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.datasets.pbmc3k_processed : Processed 3k PBMCs from 10x Genomics. Processed using the `basic tutorial `__. Similarity score: 0.3449263274669647\n - scanpy.tl.leiden : Cluster cells into subgroups [Traag18]_. Cluster cells using the Leiden algorithm [Traag18]_, an improved version of the Louvain algorithm [Blondel08]_. Similarity score: 0.34451180696487427\n - scanpy.tl.dendrogram : Computes a hierarchical clustering for the given `groupby` categories. By default, the PCA representation is used unless `. X` has less than 50 variables. Similarity score: 0.3311234414577484", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-257", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-257", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-28", + "task": "The task is to identify clusters in processed data, which helps group similar items together. We solved it by using the `scanpy.tl.leiden` function, a tool that organizes data into clusters based on cell similarities, allowing us to specify various settings like how fine or coarse we want the clustering to be.", + "task_title": "Predicted API: scanpy.tl.leiden", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-29", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-259", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-259", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-259", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-259", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-259", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-259", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-30", + "task": "Here are the task description with keywords highlighted as evidence: \nCould you identify clusters in the processed data using the Leiden algorithm with 'resolution' set as 1 and 'key_added' set as 'leiden'?", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-260", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-260", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-31", + "task": "from scanpy.tl import leiden\nresult_3 = leiden(result_1, copy=False)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-32", + "task": "The task is to group cells into smaller, related clusters using a method called the Leiden algorithm, which helps in analyzing single-cell data. We solved it by using the `leiden` function from the Scanpy library, where we provided the data we wanted to analyze and chose not to create a copy of the data for this operation. In this function, we can control how finely we want to cluster the cells (using the resolution parameter) and ensure the clustering stays relevant by using previously defined connections between the cells.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-33", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-263", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-263", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-263", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-263", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-263", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-263", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-34", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-35", + "task": "Executed successfully! No new variable obtained", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-36", + "task": "Current and remaining tasks: \n → step 4: Please compute cluster centroids for further analysis.\n - step 5: Can you create a scatter plot to visualize clusters?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-266", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-266", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-266", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-37", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.tl.leiden : Cluster cells into subgroups [Traag18]_. Cluster cells using the Leiden algorithm [Traag18]_, an improved version of the Louvain algorithm [Blondel08]_. Similarity score: 0.42832815647125244\n - scanpy.tl.dendrogram : Computes a hierarchical clustering for the given `groupby` categories. By default, the PCA representation is used unless `. X` has less than 50 variables. Similarity score: 0.3229776918888092\n - scanpy.tl.louvain : Cluster cells into subgroups [Blondel08]_ [Levine15]_ [Traag17]_. Cluster cells using the Louvain algorithm [Blondel08]_ in the implementation of [Traag17]_. Similarity score: 0.2857111394405365", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-267", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-267", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-38", + "task": "The task is to compute cluster centroids for further analysis of cell groups in a dataset. We solved it by using the `scanpy.tl.leiden` function, which groups cells into clusters based on their similarities, allowing us to identify and analyze the characteristics of each cluster.", + "task_title": "Predicted API: scanpy.tl.leiden", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-39", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-269", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-269", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-269", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-269", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-269", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-269", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-40", + "task": "Here are the task description with keywords highlighted as evidence: \nPlease compute cluster centroids using the Leiden clustering results stored under the key 'leiden' in `result_1`.", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-270", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-270", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-41", + "task": "from scanpy.tl import leiden\nresult_4 = leiden(result_1, copy=False)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-42", + "task": "The task is to group cells into different subcategories to better analyze single-cell data. We solved it by using the `leiden` function from the Scanpy library, which efficiently clusters the cells based on their similarities. In the generated code, we specified that we don't want to create a copy of the data (`copy=False`), and the underlying algorithm automatically uses parameters like `resolution` to determine how detailed the clustering should be, with higher values resulting in more distinct clusters.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-43", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-273", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-273", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-273", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-273", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-273", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-273", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-44", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-45", + "task": "Executed successfully! No new variable obtained", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-46", + "task": "Current and remaining tasks: \n → step 5: Can you create a scatter plot to visualize clusters?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-276", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-276", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-276", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-276", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-47", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pl.draw_graph : Scatter plot in graph-drawing basis. Similarity score: 0.40696781873703003\n - scanpy.pl.embedding : Scatter plot for user specified embedding basis (e. g. umap, pca, etc) Similarity score: 0.39931315183639526\n - scanpy.pl.scatter : Scatter plot along observations or variables axes. Color the plot using annotations of observations (`. obs`), variables (`. var`) or expression of genes (`. var_names`). Similarity score: 0.380614697933197", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-277", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-277", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-48", + "task": "The task is to create a scatter plot that helps visualize clusters in our data. We solved it by using a function called `scanpy.pl.scatter`, which allows us to specify the axes, colors, and other details to effectively display the data points and their relationships visually.", + "task_title": "Predicted API: scanpy.pl.scatter", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-49", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-279", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-279", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-279", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-279", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-279", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-279", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-50", + "task": "Here are the task description with keywords highlighted as evidence: \nCan you create a scatter plot to visualize clusters using 'adata' from the processed PMBC dataset, with 'x' as 'X_umap' and 'y' as 'X_tsne'?", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-51", + "task": "The predicted API takes Keys for annotations of observations/cells or variables/genes,\nor a hex color specification, e.g.,\n`'ann1'`, `'#fe57a1'`, or `['ann1', 'ann2']`.('color': Union[str, Collection[str]]), as input. However, there are still some parameters undefined in the query.", + "task_title": "Enter Parameters: basic type", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "red" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-281", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-281", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-52", + "task": "Which value do you think is appropriate for the parameters 'color'?", + "task_title": "Enter Parameters: basic type", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "red" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "'percent_mito'", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-282", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-282", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-282", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-282", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-282", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-282", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-53", + "task": "from scanpy.pl import scatter\nscatter(result_1, x='X_umap', y='X_tsne', color='percent_mito', basis='umap', show=True)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-54", + "task": "The task is to create a scatter plot that visualizes the relationship between two types of data representations, specifically 'X_umap' and 'X_tsne', while coloring the points based on the proportion of mitochondrial genes within the cells, referred to as 'percent_mito'. We solved it by using the `scatter` function from the Scanpy library, specifying the axes for the plot, the data to determine point colors, and indicating that the visualization should appear in a 'umap' format. This approach helps us easily see how the amount of mitochondrial genes in the cells varies across the plotted data points.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-55", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-285", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-285", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-285", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-285", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-285", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-285", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-56", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-56", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-57", + "task": "Executed successfully! No new variable obtained", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-58", + "task": "We visualize the obtained figure. Try to zoom in or out the figure.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "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", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-59", + "task": "We interpret the obtained figure: The scatter plot reveals distinct clusters in the PMBC dataset, with varying percentages of mitochondrial content, suggesting significant heterogeneity in cell populations based on mitochondrial gene expression.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-60", + "task": "We visualize the obtained figure. Try to zoom in or out the figure.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "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", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-61", + "task": "We interpret the obtained figure: The scatter plot reveals distinct clusters of cells with varying mitochondrial percentages, indicating heterogeneity in the PMBC dataset.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-62", + "task": "We will start another round. Could you re-enter your inquiry?", + "task_title": "Start another round", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "648cac99-4dbc-41e5-b3e1-166f1b49f1d7", + "mode": "T" + } + ], + "top_k": 1, + "folderId": null, + "Lib": "scanpy", + "files": [], + "new_lib_github_url": "", + "new_lib_doc_url": "", + "api_html": "", + "lib_alias": "", + "conversation_started": true, + "session_id": "", + "mode": "T" + }, + { + "id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "name": "新的聊天", + "method": { + "id": "No specified", + "name": "DFS without filter", + "method": "No specified", + "maxLength": 8000 + }, + "messages": [ + { + "role": "assistant", + "content": "", + "tools": [ + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "log-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "[Would you like to see some examples to learn how to interact with the bot?](https://github.com/batmen-lab/BioMANIA/tree/35da76f7d5cd40b99980654e84000e25ff167cb2/examples)", + "task_title": "Welcome to BioMANIA! How can I help?", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + } + ], + "recommendations": [], + "files": [], + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "T" + }, + { + "role": "user", + "content": "I need to load the built-in pbmc3k processed dataset", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": true, + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "S" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-303", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-303", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-2", + "task": "No data are uploaded! Would you ensure to go on?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn.", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "S" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-304", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-304", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-304", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-304", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-304", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-304", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-304", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-304", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-304", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-3", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.datasets.pbmc3k_processed : Processed 3k PBMCs from 10x Genomics. Processed using the `basic tutorial io/en/latest/pbmc3k. html>`__. Similarity score: 0.7312601804733276\n - scanpy.datasets.pbmc3k : 3k PBMCs from 10x Genomics. The data consists in 3k PBMCs from a Healthy Donor and is freely available from 10x Genomics (`here `__ from this `webpage 0/pbmc3k>`__). Similarity score: 0.6363131999969482\n - scanpy.datasets.pbmc68k_reduced : Subsampled and processed 68k PBMCs. 10x PBMC 68k dataset from https://support. 10xgenomics. com/single-cell-gene-expression/datasets The original PBMC 68k dataset was preprocessed using scanpy and was saved keeping only 724 cells and 221 highly variable genes. Similarity score: 0.5290886163711548", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-305", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-305", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-4", + "task": "The task is to load a pre-processed dataset of 3,000 PBMC (peripheral blood mononuclear cells) from a scientific source. We solved it by using the `scanpy.datasets.pbmc3k_processed()` function, which gives us a ready-to-use data matrix for analysis.", + "task_title": "Predicted API: scanpy.datasets.pbmc3k_processed", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-5", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "S" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-307", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-307", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-307", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-307", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-307", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-307", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-6", + "task": "Here are the task description with keywords highlighted as evidence: \nI need to load the built-in pbmc3k processed dataset", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-308", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-308", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-7", + "task": "from scanpy.datasets import pbmc3k_processed\nresult_1 = pbmc3k_processed()", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-8", + "task": "The task is to obtain a processed dataset of 3,000 blood cells from a specific scientific study for analysis. We solved it by using the `pbmc3k_processed()` function from the Scanpy library, which gives us an annotated data matrix that has already been prepared for use. In the code, `from scanpy.datasets import pbmc3k_processed` imports the necessary function, and `result_1 = pbmc3k_processed()` calls the function to get the dataset, storing it in the variable `result_1` for later use.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-9", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "S" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-311", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-311", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-311", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-311", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-311", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-311", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-10", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-11", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n var: 'n_cells'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-12", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain\nAAACATACAACCAC-1,781,0.030177759,2419.0,CD4 T cells\nAAACATTGAGCTAC-1,1352,0.037935957,4903.0,B cells\nAAACATTGATCAGC-1,1131,0.008897362,3147.0,CD4 T cells\nAAACCGTGCTTCCG-1,960,0.017430846,2639.0,CD14+ Monocytes\nAAACCGTGTATGCG-1,522,0.012244898,980.0,NK cells", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-13", + "task": "Could you enter your next inquiry?", + "task_title": "Enter inquiry", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "T" + }, + { + "role": "user", + "content": "Could you visualize the genes expression values through heatmap?", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "S" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-315", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-315", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-315", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-315", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-14", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pl.heatmap : Heatmap of the expression values of genes. If `groupby` is given, the heatmap is ordered by the respective group. Similarity score: 0.6687601804733276\n - scanpy.pl.matrixplot : Creates a heatmap of the mean expression values per group of each var_names. This function provides a convenient interface to the :class:`~scanpy. pl. MatrixPlot` class. Similarity score: 0.4662947356700897\n - scanpy.pl.rank_genes_groups_heatmap : Plot ranking of genes using heatmap plot (see :func:`~scanpy. pl. heatmap`) Similarity score: 0.45185089111328125", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-316", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-316", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-15", + "task": "The task is to visualize gene expression values using a heatmap, which helps us see patterns in gene activity across different conditions or groups. We solved it by using the `scanpy.pl.heatmap` function, which takes the gene expression data and specified genes to create a visual representation where colors indicate the level of expression.", + "task_title": "Predicted API: scanpy.pl.heatmap", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-16", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "S" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-318", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-318", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-318", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-318", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-318", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-318", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-17", + "task": "Here are the task description with keywords highlighted as evidence: \nCould you visualize the genes expression values through heatmap with 'var_names' set as a valid subset of 'adata.var_names' and 'groupby' set as 'louvain'?", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-319", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-319", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-18", + "task": "from scanpy.pl import heatmap\nheatmap(result_1, 'adata.var_names', 'louvain', log=True, standard_scale='var', show=True)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-19", + "task": "The task is to create a heatmap that displays gene expression values from a dataset and organizes it based on specific groupings, such as cell types. We solved it by using the `heatmap` function from the Scanpy library, providing it with the data, specifying the genes to plot, choosing the grouping method (`louvain`), and enabling logarithmic scaling for better visualization. The parameters in the code indicate that we want to standardize the data across genes for clarity and ensure the heatmap is displayed immediately with `show=True`.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-20", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "S" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-322", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-322", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-322", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-322", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-322", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-322", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-21", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-22", + "task": "KeyError: \"Could not find keys '['adata.var_names']' in columns of `adata.obs` or in adata.raw.var_names.\"", + "task_title": "Executed results [Fail]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-23", + "task": "The bug arises due to the incorrect usage of the `var_names` parameter, where it should directly reference the existing `var_names` from the AnnData object instead of the string 'adata.var_names'. To correct this, we must replace 'adata.var_names' with a valid subset of `result_1.var_names` and ensure that we are using existing gene names for the heatmap visualization.", + "task_title": "Error Analysis, retry count: 1/5", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "code-24", + "task": "import scanpy as sc\n\nheatmap_result = sc.pl.heatmap(result_1, var_names=result_1.var_names[:10], groupby='louvain', log=True, standard_scale='var', show=True)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-25", + "task": "The task is to create a heatmap that visually represents the expression levels of genes using data about different groups of cells. We solved it by using the `scanpy.pl.heatmap` function, where we specified the first 10 gene names to plot, grouped the data by the 'louvain' clustering, applied a logarithmic scale for better visibility, and standardized the expression levels across the genes. By setting `show=True`, we ensured that the heatmap would be displayed after it's generated.", + "task_title": "Code explanation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-327", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-327", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-27", + "task": "Executed successfully! No new variable obtained", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-28", + "task": "We visualize the obtained figure. Try to zoom in or out the figure.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "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", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-29", + "task": "We interpret the obtained figure: The heatmap reveals distinct gene expression patterns among various immune cell types, highlighting specific markers that differentiate cell populations, particularly in CD4 T cells and CD14+ Monocytes.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-30", + "task": "Could you enter your next inquiry?", + "task_title": "Enter inquiry", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "42799689-1ccb-4ca5-9e53-10fa5ea451e7", + "mode": "T" + } + ], + "top_k": 1, + "folderId": null, + "Lib": "scanpy", + "files": [], + "new_lib_github_url": "", + "new_lib_doc_url": "", + "api_html": "", + "lib_alias": "", + "conversation_started": true, + "session_id": "", + "mode": "T" + }, + { + "id": "93f77b77-662f-4683-b732-a8a6759cf9cd", + "name": "新的聊天", + "method": { + "id": "No specified", + "name": "DFS without filter", + "method": "No specified", + "maxLength": 8000 + }, + "messages": [ + { + "role": "assistant", + "content": "", + "tools": [ + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "log-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "[Would you like to see some examples to learn how to interact with the bot?](https://github.com/batmen-lab/BioMANIA/tree/35da76f7d5cd40b99980654e84000e25ff167cb2/examples)", + "task_title": "Welcome to BioMANIA! How can I help?", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + } + ], + "recommendations": [], + "files": [], + "session_id": "93f77b77-662f-4683-b732-a8a6759cf9cd", + "mode": "T" + }, + { + "role": "user", + "content": "I need to load the built-in pbmc3k processed dataset\n\n\n", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": true, + "session_id": "93f77b77-662f-4683-b732-a8a6759cf9cd", + "mode": "S" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-415", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-415", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-2", + "task": "No data are uploaded! Would you ensure to go on?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn.", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "93f77b77-662f-4683-b732-a8a6759cf9cd", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "93f77b77-662f-4683-b732-a8a6759cf9cd", + "mode": "S" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-416", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-416", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-416", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-416", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-416", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-416", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-416", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-416", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-416", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-416", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-3", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.datasets.pbmc3k_processed : Processed 3k PBMCs from 10x Genomics. Processed using the `basic tutorial io/en/latest/pbmc3k. html>`__. Similarity score: 0.7312601804733276\n - scanpy.datasets.pbmc3k : 3k PBMCs from 10x Genomics. The data consists in 3k PBMCs from a Healthy Donor and is freely available from 10x Genomics (`here `__ from this `webpage 0/pbmc3k>`__). Similarity score: 0.6363131999969482\n - scanpy.datasets.pbmc68k_reduced : Subsampled and processed 68k PBMCs. 10x PBMC 68k dataset from https://support. 10xgenomics. com/single-cell-gene-expression/datasets The original PBMC 68k dataset was preprocessed using scanpy and was saved keeping only 724 cells and 221 highly variable genes. Similarity score: 0.5290886163711548", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-417", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-417", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-4", + "task": "The task is to load a specific dataset called the processed 3k PBMCs from 10x Genomics, which contains analyzed data for cell studies. We solved it by using the `scanpy.datasets.pbmc3k_processed()` function, which allows us to easily access this pre-processed data for further research.", + "task_title": "Predicted API: scanpy.datasets.pbmc3k_processed", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-5", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "93f77b77-662f-4683-b732-a8a6759cf9cd", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "93f77b77-662f-4683-b732-a8a6759cf9cd", + "mode": "S" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-419", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-419", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-419", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-419", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-419", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-419", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-6", + "task": "Here are the task description with keywords highlighted as evidence: \nI need to load the built-in pbmc3k processed dataset\n\n\n", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-420", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-420", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-7", + "task": "from scanpy.datasets import pbmc3k_processed\nresult_1 = pbmc3k_processed()", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-8", + "task": "The task is to retrieve a processed dataset of three thousand PBMC (peripheral blood mononuclear cells) samples from a specific source, which is useful for various biological analyses. We solved it by using a function from a library called Scanpy, specifically `pbmc3k_processed`, which gives us an annotated data matrix of the samples. In the code, `from scanpy.datasets import pbmc3k_processed` imports the function, and `result_1 = pbmc3k_processed()` actually fetches the dataset, storing it in `result_1` for further use.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-9", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "93f77b77-662f-4683-b732-a8a6759cf9cd", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "93f77b77-662f-4683-b732-a8a6759cf9cd", + "mode": "S" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-423", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-423", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-423", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-423", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-423", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-423", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-10", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-11", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n var: 'n_cells'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-12", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain\nAAACATACAACCAC-1,781,0.030177759,2419.0,CD4 T cells\nAAACATTGAGCTAC-1,1352,0.037935957,4903.0,B cells\nAAACATTGATCAGC-1,1131,0.008897362,3147.0,CD4 T cells\nAAACCGTGCTTCCG-1,960,0.017430846,2639.0,CD14+ Monocytes\nAAACCGTGTATGCG-1,522,0.012244898,980.0,NK cells", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-13", + "task": "Could you enter your next inquiry?", + "task_title": "Enter inquiry", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "93f77b77-662f-4683-b732-a8a6759cf9cd", + "mode": "T" + } + ], + "top_k": 1, + "folderId": null, + "Lib": "scanpy", + "files": [], + "new_lib_github_url": "", + "new_lib_doc_url": "", + "api_html": "", + "lib_alias": "", + "conversation_started": true, + "session_id": "", + "mode": "T" + }, + { + "id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "name": "新的聊天", + "method": { + "id": "No specified", + "name": "DFS without filter", + "method": "No specified", + "maxLength": 8000 + }, + "messages": [ + { + "role": "assistant", + "content": "", + "tools": [ + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "log-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "[Would you like to see some examples to learn how to interact with the bot?](https://github.com/batmen-lab/BioMANIA/tree/35da76f7d5cd40b99980654e84000e25ff167cb2/examples)", + "task_title": "Welcome to BioMANIA! How can I help?", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "I need to load the built-in pbmc3k processed dataset", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": true, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-637", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-637", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-2", + "task": "No data are uploaded! Would you ensure to go on?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn.", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-638", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-638", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-638", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-638", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-638", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-638", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-638", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-638", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-638", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-638", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-3", + "task": "Current and remaining tasks: \n → step 1: Please load the built-in pbmc3k processed dataset.\n - step 2: Could you filter the data to remove unwanted cells?\n - step 3: Please normalize the data for consistency across samples.\n - step 4: Could you perform dimensionality reduction on the data?\n - step 5: Can you plot the UMAP representation of the data?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-4", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.datasets.pbmc3k_processed : Processed 3k PBMCs from 10x Genomics. Processed using the `basic tutorial io/en/latest/pbmc3k. html>`__. Similarity score: 0.7630695104598999\n - scanpy.datasets.pbmc3k : 3k PBMCs from 10x Genomics. The data consists in 3k PBMCs from a Healthy Donor and is freely available from 10x Genomics (`here 1. 0/pbmc3k/pbmc3k_filtered_gene_bc_matrices. tar. gz>`__ from this `webpage 1. 0/pbmc3k>`__). Similarity score: 0.6117509007453918\n - scanpy.datasets.pbmc68k_reduced : Subsampled and processed 68k PBMCs. 10x PBMC 68k dataset from https://support. 10xgenomics. com/single-cell-gene-expression/datasets The original PBMC 68k dataset was preprocessed using scanpy and was saved keeping only 724 cells and 221 highly variable genes. Similarity score: 0.5205820202827454", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-640", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-640", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-5", + "task": "The task is to load a pre-processed dataset of 3,000 blood cells from a specific biological study. We solved it by using the function `scanpy.datasets.pbmc3k_processed()`, which gives us an organized data table ready for analysis.", + "task_title": "Predicted API: scanpy.datasets.pbmc3k_processed", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-6", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-642", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-642", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-642", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-642", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-642", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-642", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-7", + "task": "Here are the task description with keywords highlighted as evidence: \nstep 1: Please load the built-in pbmc3k processed dataset.", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-643", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-643", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-8", + "task": "from scanpy.datasets import pbmc3k_processed\nresult_1 = pbmc3k_processed()", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-9", + "task": "The task is to retrieve a processed dataset of 3,000 human immune cells (PBMCs) from a specific study for analysis. We solved it by using a function called `pbmc3k_processed()` from the ScanPy library, which returns this data in a structured format. In the generated code, we import the function and call it, storing the result in a variable named `result_1`, which now holds the annotated data ready for further exploration.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-10", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-646", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-646", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-646", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-646", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-646", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-646", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-11", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-12", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n var: 'n_cells'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-13", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain\nAAACATACAACCAC-1,781,0.030177759,2419.0,CD4 T cells\nAAACATTGAGCTAC-1,1352,0.037935957,4903.0,B cells\nAAACATTGATCAGC-1,1131,0.008897362,3147.0,CD4 T cells\nAAACCGTGCTTCCG-1,960,0.017430846,2639.0,CD14+ Monocytes\nAAACCGTGTATGCG-1,522,0.012244898,980.0,NK cells", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-14", + "task": "Current and remaining tasks: \n → step 2: Could you filter the data to remove unwanted cells?\n - step 3: Please normalize the data for consistency across samples.\n - step 4: Could you perform dimensionality reduction on the data?\n - step 5: Can you plot the UMAP representation of the data?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-650", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-650", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-650", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-650", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-15", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pp.filter_cells : Filter cell outliers based on counts and numbers of genes expressed. For instance, only keep cells with at least `min_counts` counts or `min_genes` genes expressed. Similarity score: 0.46103572845458984\n - scanpy.pp.filter_genes : Filter genes based on number of cells or counts. Keep genes that have at least `min_counts` counts or are expressed in at least `min_cells` cells or have at most `max_counts` counts or are expressed in at most `max_cells` cells. Similarity score: 0.3167329728603363\n - scanpy.datasets.ebi_expression_atlas : Load a dataset from the `EBI Single Cell Expression Atlas`__ Downloaded datasets are saved in the directory specified by :attr:`~scanpy. _settings. ScanpyConfig. datasetdir`. Similarity score: 0.25380396842956543", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-651", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-651", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-16", + "task": "The task is to filter out unwanted cells from a dataset based on certain criteria, such as the minimum number of genes they express or the number of counts they have. We solved it by using the `filter_cells` function from the Scanpy library, which helps us keep only the reliable cells that meet our specified thresholds, allowing for cleaner data analysis.", + "task_title": "Predicted API: scanpy.pp.filter_cells", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-17", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-653", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-653", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-653", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-653", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-653", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-653", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-18", + "task": "Here are the task description with keywords highlighted as evidence: \nCould you filter the data to remove unwanted cells with 'min_genes' set as 3?", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-654", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-654", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-19", + "task": "from scanpy.pp import filter_cells\nresult_2 = filter_cells(result_1, min_genes=3, inplace=True, copy=False)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-20", + "task": "The task is to filter out unreliable cells from a dataset by ensuring that each cell expresses a minimum number of genes. We solved it by using the `filter_cells` function from the Scanpy library, specifically setting the parameter `min_genes` to 3, which means we only keep cells that express at least 3 different genes. We chose `inplace=True` so the filtering happens directly in the original dataset without creating a copy.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-21", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-657", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-657", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-657", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-657", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-657", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-657", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-22", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-23", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n var: 'n_cells'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-24", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain\nAAACATACAACCAC-1,144,0.030177759,2419.0,CD4 T cells\nAAACATTGAGCTAC-1,341,0.037935957,4903.0,B cells\nAAACATTGATCAGC-1,217,0.008897362,3147.0,CD4 T cells\nAAACCGTGCTTCCG-1,186,0.017430846,2639.0,CD14+ Monocytes\nAAACCGTGTATGCG-1,157,0.012244898,980.0,NK cells", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-25", + "task": "Current and remaining tasks: \n → step 3: Please normalize the data for consistency across samples.\n - step 4: Could you perform dimensionality reduction on the data?\n - step 5: Can you plot the UMAP representation of the data?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-661", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-661", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-661", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-661", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-26", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pp.normalize_total : Normalize counts per cell. Normalize each cell by total counts over all genes, so that every cell has the same total count after normalization. Similarity score: 0.3504718840122223\n - scanpy.pp.recipe_weinreb17 : Normalization and filtering as of [Weinreb17]_. Expects non-logarithmized data. Similarity score: 0.31500276923179626\n - scanpy.experimental.pp.normalize_pearson_residuals : Applies analytic Pearson residual normalization, based on [Lause21]_. The residuals are based on a negative binomial offset model with overdispersion `theta` shared across genes. Similarity score: 0.3016819953918457", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-662", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-662", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-27", + "task": "The task is to normalize the data to ensure that the values across different samples are consistent. We solved it by using the `scanpy.pp.normalize_total` function, which adjusts the counts for each cell to a target sum, allowing us to either exclude highly expressed genes or include them based on set parameters for more accurate normalization.", + "task_title": "Predicted API: scanpy.pp.normalize_total", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-28", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-664", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-664", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-664", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-664", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-664", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-664", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-29", + "task": "Here are the task description with keywords highlighted as evidence: \nPlease normalize the data for consistency across samples by setting 'target_sum' as '1e6' and 'max_fraction' as '0.05'.", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-665", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-665", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-30", + "task": "from scanpy.pp import normalize_total\nresult_3 = normalize_total(result_1, target_sum=1e6, copy=False, inplace=True)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-31", + "task": "The task is to adjust the counts of genes in each cell so that they all have the same total count, essentially normalizing the data for better comparison. We solved it by using the `normalize_total` function from the Scanpy library, where we set the `target_sum` to 1 million (1e6) to scale the counts accordingly and chose to modify the original data directly with `inplace=True`. This way, the high-count genes' influence on normalization can be effectively managed and the data becomes easier to analyze across different cells.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-32", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-668", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-668", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-668", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-668", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-668", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-668", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-33", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-34", + "task": "Executed successfully! No new variable obtained", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-35", + "task": "Current and remaining tasks: \n → step 4: Could you perform dimensionality reduction on the data?\n - step 5: Can you plot the UMAP representation of the data?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-671", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-671", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-671", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-671", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-36", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pp.neighbors : Compute a neighborhood graph of observations [McInnes18]_. The neighbor search efficiency of this heavily relies on UMAP [McInnes18]_, which also provides a method for estimating connectivities of data points - the connectivity of the manifold (`method=='umap'`). Similarity score: 0.30197325348854065\n - scanpy.tl.pca : Principal component analysis [Pedregosa11]_. Computes PCA coordinates, loadings and variance decomposition. Similarity score: 0.29150283336639404\n - scanpy.pp.pca : Principal component analysis [Pedregosa11]_. Computes PCA coordinates, loadings and variance decomposition. Similarity score: 0.2834059000015259", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-672", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-672", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-37", + "task": "The task is to reduce the complexity of our data by performing dimensionality reduction. We solved it by using a function called PCA (Principal Component Analysis) from the Scanpy library, which simplifies the data while preserving important information by transforming it into a smaller set of variables.", + "task_title": "Predicted API: scanpy.tl.pca", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-38", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-674", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-674", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-674", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-674", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-674", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-674", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-39", + "task": "Here are the task description with keywords highlighted as evidence: \nCould you perform dimensionality reduction using PCA on the data with 'n_comps' set to 50?", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-675", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-675", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-40", + "task": "from scanpy.tl import pca\nresult_4 = pca(result_1, n_comps=50, copy=False)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-41", + "task": "The task is to perform a statistical technique called Principal Component Analysis (PCA) to help analyze and visualize the differences in gene expression data from cells. We solved it by using the `pca` function from the Scanpy library, specifying that we want to calculate 50 principal components without creating a copy of the original data. By setting `n_comps=50`, we determine how many principal components to calculate, and `copy=False` means we modify the original data structure rather than creating a new one.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-42", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-678", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-678", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-678", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-678", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-678", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-678", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-43", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-44", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n var: 'n_cells'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-45", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain\nAAACATACAACCAC-1,144,0.030177759,2419.0,CD4 T cells\nAAACATTGAGCTAC-1,341,0.037935957,4903.0,B cells\nAAACATTGATCAGC-1,217,0.008897362,3147.0,CD4 T cells\nAAACCGTGCTTCCG-1,186,0.017430846,2639.0,CD14+ Monocytes\nAAACCGTGTATGCG-1,157,0.012244898,980.0,NK cells", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-46", + "task": "Current and remaining tasks: \n → step 5: Can you plot the UMAP representation of the data?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-682", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-682", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-682", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-682", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-47", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.pl.umap : Scatter plot in UMAP basis. Similarity score: 0.4896407425403595\n - scanpy.tl.umap : Embed the neighborhood graph using UMAP [McInnes18]_. UMAP (Uniform Manifold Approximation and Projection) is a manifold learning technique suitable for visualizing high-dimensional data. Similarity score: 0.4582052230834961\n - scanpy.pl.sim : Plot results of simulation. Similarity score: 0.25699445605278015", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-683", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-683", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-48", + "task": "The task is to create a visual representation of data using UMAP, which helps in understanding the relationships between different data points. We solved it by using the `scanpy.pl.umap` function, which generates a scatter plot based on the provided data and highlights various features, such as color coding based on gene expression or different categories.", + "task_title": "Predicted API: scanpy.pl.umap", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-49", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-685", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-685", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-685", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-685", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-685", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-685", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-50", + "task": "Here are the task description with keywords highlighted as evidence: \nCan you plot the UMAP representation of the data with 'color' set as 'louvain' and 'projection' set as '2d'?", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-686", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-686", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-51", + "task": "from scanpy.pl import umap\nresult_5 = umap(result_1, color='louvain', layer='X_new', show=True)", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-52", + "task": "The task is to visualize different groups of cells based on their characteristics using a method called UMAP, which helps to create a clear scatter plot. We solved it by using the `umap` function from a library called Scanpy, specifying `color='louvain'` to color the points based on the Louvain clustering results, and `layer='X_new'` to indicate which data layer to use for this visualization. The `show=True` parameter ensures that the plot will be displayed once it's generated.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-53", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-689", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-689", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-689", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-689", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-689", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-689", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-54", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-55", + "task": "Executed successfully! No new variable obtained", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-56", + "task": "We visualize the obtained figure. Try to zoom in or out the figure.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "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", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-57", + "task": "We interpret the obtained figure: The UMAP representation reveals distinct clustering of various immune cell types, indicating significant differences in their distributions and relationships in the dataset.", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-58", + "task": "We will start another round. Could you re-enter your inquiry?", + "task_title": "Start another round", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "a5dc3f52-3575-4664-97be-b9514dd6ebca", + "mode": "T" + } + ], + "top_k": 1, + "folderId": null, + "Lib": "scanpy", + "files": [], + "new_lib_github_url": "", + "new_lib_doc_url": "", + "api_html": "", + "lib_alias": "", + "conversation_started": true, + "session_id": "", + "mode": "T" + }, + { + "id": "94c54461-5eb8-4411-97f4-3bb47ecf703e", + "name": "新的聊天", + "method": { + "id": "No specified", + "name": "DFS without filter", + "method": "No specified", + "maxLength": 8000 + }, + "messages": [ + { + "role": "assistant", + "content": "", + "tools": [ + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "tool-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "", + "task_title": "", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + }, + { + "type": "tool", + "block_id": "log-1", + "occurence": 1, + "Parameters": "", + "status": 0, + "api_name": "", + "api_description": "", + "api_calling": "", + "task": "[Would you like to see some examples to learn how to interact with the bot?](https://github.com/batmen-lab/BioMANIA/tree/35da76f7d5cd40b99980654e84000e25ff167cb2/examples)", + "task_title": "Welcome to BioMANIA! How can I help?", + "composite_code": "", + "ongoing": false, + "depth": 0, + "children": [], + "parent": null + } + ], + "recommendations": [], + "files": [], + "session_id": "94c54461-5eb8-4411-97f4-3bb47ecf703e", + "mode": "T" + }, + { + "role": "user", + "content": "can you do the clustering?", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": true, + "session_id": "94c54461-5eb8-4411-97f4-3bb47ecf703e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-58", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-58", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-2", + "task": "No data are uploaded! Would you ensure to go on?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn.", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "94c54461-5eb8-4411-97f4-3bb47ecf703e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "94c54461-5eb8-4411-97f4-3bb47ecf703e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-59", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-59", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-59", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-59", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-59", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-59", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-59", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-59", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-59", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-59", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-3", + "task": "Current and remaining tasks: \n → step 1: Please load the built-in dataset for clustering.\n - step 2: Could you filter the data for relevant observations?\n - step 3: Please normalize the data to prepare for clustering.\n - step 4: Can you compute the nearest neighbors for the data?\n - step 5: Could you draw the clustering results as a scatter plot?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-4", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.tl.leiden : Cluster cells into subgroups [Traag18]_. Cluster cells using the Leiden algorithm [Traag18]_, an improved version of the Louvain algorithm [Blondel08]_. Similarity score: 0.3167596757411957\n - scanpy.datasets.pbmc3k_processed : Processed 3k PBMCs from 10x Genomics. Processed using the `basic tutorial `__. Similarity score: 0.31580570340156555\n - scanpy.datasets.ebi_expression_atlas : Load a dataset from the `EBI Single Cell Expression Atlas`__ Downloaded datasets are saved in the directory specified by :attr:`~scanpy. _settings. ScanpyConfig. datasetdir`. Similarity score: 0.2939551770687103", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-61", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-61", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-5", + "task": "The task is to load a built-in dataset for clustering analysis. We solved it by using the `scanpy.datasets.pbmc3k_processed()` function, which provides an annotated data matrix of processed PBMCs (Peripheral Blood Mononuclear Cells) from 10x Genomics.", + "task_title": "Predicted API: scanpy.datasets.pbmc3k_processed", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-6", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "94c54461-5eb8-4411-97f4-3bb47ecf703e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "94c54461-5eb8-4411-97f4-3bb47ecf703e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-63", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-63", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-63", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-63", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-63", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-63", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-7", + "task": "Here are the task description with keywords highlighted as evidence: \nstep 1: Please load the built-in dataset for clustering.", + "task_title": "Polished task description", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-64", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-64", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "code-8", + "task": "from scanpy.datasets import pbmc3k_processed\nresult_1 = pbmc3k_processed()", + "task_title": "Executed code", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-9", + "task": "The task is to fetch a processed dataset of 3,000 blood cells from a specific experiment for analysis. We solved it by using a pre-built function from the Scanpy library that retrieves this dataset with the code `from scanpy.datasets import pbmc3k_processed` followed by `result_1 = pbmc3k_processed()`. Here, `pbmc3k_processed()` is the function that loads the data, and `result_1` is the variable where we store this dataset for further use.", + "task_title": "Task summary", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-10", + "task": "Could you confirm whether this task is what you aimed for, and the code should be executed?\nEnter [y]: Go on please\nEnter [n]: Re-direct to the parameter input step\nEnter [r]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "94c54461-5eb8-4411-97f4-3bb47ecf703e", + "mode": "T" + }, + { + "role": "user", + "content": "y", + "tools": [], + "recommendations": [], + "files": [], + "conversation_started": false, + "session_id": "94c54461-5eb8-4411-97f4-3bb47ecf703e", + "mode": "T" + }, + { + "role": "assistant", + "content": "", + "tools": [ + { + "method_name": "on_tool_start", + "block_id": "tool-67", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-67", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-67", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-67", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-67", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-67", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-11", + "task": "\n", + "task_title": "Executing results", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-12", + "task": "We obtain a new variable result_1: AnnData object with n_obs × n_vars = 2638 × 1838\n obs: 'n_genes', 'percent_mito', 'n_counts', 'louvain'\n var: 'n_cells'\n uns: 'draw_graph', 'louvain', 'louvain_colors', 'neighbors', 'pca', 'rank_genes_groups'\n obsm: 'X_pca', 'X_tsne', 'X_umap', 'X_draw_graph_fr'\n varm: 'PCs'\n obsp: 'distances', 'connectivities'", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-13", + "task": "We visualize the first 5 rows of the table data", + "task_title": "Executed results [Success]", + "composite_code": "", + "imageData": "", + "tableData": "index,n_genes,percent_mito,n_counts,louvain\nAAACATACAACCAC-1,781,0.030177759,2419.0,CD4 T cells\nAAACATTGAGCTAC-1,1352,0.037935957,4903.0,B cells\nAAACATTGATCAGC-1,1131,0.008897362,3147.0,CD4 T cells\nAAACCGTGCTTCCG-1,960,0.017430846,2639.0,CD14+ Monocytes\nAAACCGTGTATGCG-1,522,0.012244898,980.0,NK cells", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-14", + "task": "Current and remaining tasks: \n → step 2: Could you filter the data for relevant observations?\n - step 3: Please normalize the data to prepare for clustering.\n - step 4: Can you compute the nearest neighbors for the data?\n - step 5: Could you draw the clustering results as a scatter plot?", + "task_title": "Task Planning", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-71", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-71", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_tool_start", + "block_id": "tool-71", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-71", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-15", + "task": "Here are the retrieved API candidates with their similarity scores and keywords highlighed as evidence:\n - scanpy.get.var_df : Return values for observations in adata. Similarity score: 0.4097810983657837\n - scanpy.get.obs_df : Return values for observations in adata. Similarity score: 0.37346917390823364\n - scanpy.pp.subsample : Subsample to a fraction of the number of observations. Similarity score: 0.3529742956161499", + "task_title": "API information retrieval", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_tool_start", + "block_id": "tool-72", + "api_name": "", + "api_description": "", + "api_calling": "", + "depth": 0 + }, + { + "method_name": "on_tool_end", + "block_id": "tool-72", + "task": "", + "status": "0", + "depth": 0 + }, + { + "method_name": "on_agent_action", + "block_id": "log-16", + "task": "The task is to filter a dataset to focus on specific data points that are relevant to our interests. We solved it by using the `scanpy.get.obs_df` function, which allows us to select particular columns and values from our dataset, making it easier to analyze and visualize the information we need.", + "task_title": "Predicted API: scanpy.get.obs_df", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + }, + { + "method_name": "on_agent_action", + "block_id": "log-17", + "task": "Could you confirm whether this API should be called?\nEnter [y]: Go on please.\nEnter [n]: Restart another turn", + "task_title": "User Confirmation", + "composite_code": "", + "imageData": "", + "tableData": "", + "depth": 0, + "color": "black" + } + ], + "recommendations": [], + "files": [], + "session_id": "94c54461-5eb8-4411-97f4-3bb47ecf703e", + "mode": "T" + } + ], + "top_k": 1, + "folderId": null, + "Lib": "scanpy", + "files": [], + "new_lib_github_url": "", + "new_lib_doc_url": "", + "api_html": "", + "lib_alias": "", + "conversation_started": true, + "session_id": "", + "mode": "T" + } + ], + "folders": [], + "prompts": [] +} \ No newline at end of file diff --git a/src/report/chatbot_ui_history_10-16.py b/src/report/chatbot_ui_history_10-16.py new file mode 100644 index 0000000..55ec18c --- /dev/null +++ b/src/report/chatbot_ui_history_10-16.py @@ -0,0 +1,32 @@ +from scanpy.datasets import pbmc3k_processed +result_1 = pbmc3k_processed() +from scanpy.pp import calculate_qc_metrics +result_1.var['mito'] = result_1.var_names.str.startswith('MT-') +result_2 = calculate_qc_metrics(result_1, qc_vars=['mito'], inplace=True) +from scanpy.pp import normalize_total +result_3 = normalize_total(result_1, target_sum=1e6, max_fraction=0.05, inplace=True, copy=False) +from scanpy.tl import leiden +result_4 = leiden(result_1, key_added='louvain', copy=False) +from scanpy.pl import draw_graph +result_5 = draw_graph(result_1, color='louvain', show=True) +from scanpy.pp import filter_cells +result_3 = filter_cells(result_1, min_genes=3, inplace=True, copy=False) +result_4 = normalize_total(result_1, target_sum=1, inplace=True, copy=False) +from scanpy.pp import neighbors +result_5 = neighbors(result_1, copy=False) +from scanpy.pl import umap +result_6 = umap(result_1, color='louvain', legend_fontsize='medium', show=True) +result_2 = leiden(result_1, copy=False) +result_3 = leiden(result_1, copy=False) +result_4 = leiden(result_1, copy=False) +from scanpy.pl import scatter +scatter(result_1, x='X_umap', y='X_tsne', color='percent_mito', basis='umap', show=True) +from scanpy.pl import heatmap +import scanpy as sc + +heatmap_result = sc.pl.heatmap(result_1, var_names=result_1.var_names[:10], groupby='louvain', log=True, standard_scale='var', show=True) +result_2 = filter_cells(result_1, min_genes=3, inplace=True, copy=False) +result_3 = normalize_total(result_1, target_sum=1e6, copy=False, inplace=True) +from scanpy.tl import pca +result_4 = pca(result_1, n_comps=50, copy=False) +result_5 = umap(result_1, color='louvain', layer='X_new', show=True) \ No newline at end of file diff --git a/src/report/chatbot_ui_history_10-16_successful_code.py b/src/report/chatbot_ui_history_10-16_successful_code.py new file mode 100644 index 0000000..aebfc42 --- /dev/null +++ b/src/report/chatbot_ui_history_10-16_successful_code.py @@ -0,0 +1,36 @@ +from scanpy.datasets import pbmc3k_processed +result_1 = pbmc3k_processed() +result_1.var['mito'] = result_1.var_names.str.startswith('MT-') +result_2 = calculate_qc_metrics(result_1, qc_vars=['mito'], inplace=True) +result_3 = normalize_total(result_1, target_sum=1e6, max_fraction=0.05, inplace=True, copy=False) +from scanpy.tl import leiden +result_4 = leiden(result_1, key_added='louvain', copy=False) +from scanpy.pl import draw_graph +result_5 = draw_graph(result_1, color='louvain', show=True) +from scanpy.pp import filter_cells +result_3 = filter_cells(result_1, min_genes=3, inplace=True, copy=False) +from scanpy.pp import normalize_total +result_4 = normalize_total(result_1, target_sum=1, inplace=True, copy=False) +from scanpy.pp import neighbors +result_5 = neighbors(result_1, copy=False) +from scanpy.pl import umap +result_6 = umap(result_1, color='louvain', legend_fontsize='medium', show=True) +from scanpy.tl import leiden +result_2 = leiden(result_1, copy=False) +from scanpy.tl import leiden +result_3 = leiden(result_1, copy=False) +from scanpy.tl import leiden +result_4 = leiden(result_1, copy=False) +from scanpy.pl import scatter +scatter(result_1, x='X_umap', y='X_tsne', color='percent_mito', basis='umap', show=True) +import scanpy as sc + +heatmap_result = sc.pl.heatmap(result_1, var_names=result_1.var_names[:10], groupby='louvain', log=True, standard_scale='var', show=True) +from scanpy.pp import filter_cells +result_2 = filter_cells(result_1, min_genes=3, inplace=True, copy=False) +from scanpy.pp import normalize_total +result_3 = normalize_total(result_1, target_sum=1e6, copy=False, inplace=True) +from scanpy.tl import pca +result_4 = pca(result_1, n_comps=50, copy=False) +from scanpy.pl import umap +result_5 = umap(result_1, color='louvain', layer='X_new', show=True) \ No newline at end of file diff --git a/src/report/demo_Preprocessing_and_clustering_3k_PBMCs.ipynb b/src/report/demo_Preprocessing_and_clustering_3k_PBMCs.ipynb deleted file mode 100644 index 5f4f08c..0000000 --- a/src/report/demo_Preprocessing_and_clustering_3k_PBMCs.ipynb +++ /dev/null @@ -1,895 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "06fd0bd7", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.read_10x_mtx**\n", - "\n", - "The task is to read a directory containing files in a specific format used by 10x Genomics. We solved it by using the `scanpy.read_10x_mtx` function, which reads the `.mtx` and `.tsv` files in the directory and returns an `AnnData` object. This object contains the data from the files and can be used for further analysis." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f7a3ac71", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy import read_10x_mtx\n", - "result_1 = read_10x_mtx('./tmp')" - ] - }, - { - "cell_type": "markdown", - "id": "c764cc08", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We obtain a new AnnData object with n_obs × n_vars = 2700 × 32738\n", - " var: 'gene_ids'" - ] - }, - { - "cell_type": "markdown", - "id": "211fdde4", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We visualize the first 5 rows of the table data" - ] - }, - { - "cell_type": "markdown", - "id": "d931223c", - "metadata": {}, - "source": [ - "| Column 1 |\n", - "|--|\n", - "| AAACATACAACCAC-1 |\n", - "| AAACATTGAGCTAC-1 |\n", - "| AAACATTGATCAGC-1 |\n", - "| AAACCGTGCTTCCG-1 |\n", - "| AAACCGTGTATGCG-1 |" - ] - }, - { - "cell_type": "markdown", - "id": "4d27387c", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pl.highest_expr_genes**\n", - "\n", - "The task is to identify the genes that have the highest fraction of counts in each single cell, across all cells. We solved this by using the `scanpy.pl.highest_expr_genes` API function, which calculates the fraction of counts assigned to each gene within a cell and plots the top genes as boxplots. This helps in identifying important genes and potential issues with the data." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "20467881", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pl import highest_expr_genes\n", - "highest_expr_genes(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "cdee5929", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We visualize the obtained figure" - ] - }, - { - "cell_type": "markdown", - "id": "0d306d59", - "metadata": {}, - "source": [ - "![Image](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "id": "e981d3c7", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pp.calculate_qc_metrics**\n", - "\n", - "The task is to compute quality control metrics for a given dataset. We solved it by using the `scanpy.pp.calculate_qc_metrics` function, which calculates various metrics such as the number of genes with positive counts in a cell, the total number of counts for a cell, and the proportion of counts for specific variables. The function returns these metrics as a DataFrame or updates the dataset with the calculated metrics." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cc6c19b1", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pp import calculate_qc_metrics\n", - "calculate_qc_metrics(result_1, inplace=True)" - ] - }, - { - "cell_type": "markdown", - "id": "a50bbe6c", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "d6070a13", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pl.violin**\n", - "\n", - "The task is to create a violin plot showing the number of genes expressed, total counts per cell, and the percentage of counts in mitochondrial genes. We solved it by using the `scanpy.pl.violin` function, which wraps the `seaborn.violinplot` function and allows us to plot these measures using the provided parameters. The function returns a matplotlib axes object that can be used to further customize or save the plot." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3769dd80", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pl import violin\n", - "violin(result_1, ['n_genes_by_counts', 'total_counts'])" - ] - }, - { - "cell_type": "markdown", - "id": "30941d2e", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We visualize the obtained figure" - ] - }, - { - "cell_type": "markdown", - "id": "96b8740b", - "metadata": {}, - "source": [ - "![Image](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "id": "d7d10c13", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pl.scatter**\n", - "\n", - "The task is to create a scatter plot for the given data. We solved it by using the `scanpy.pl.scatter` function, which allows us to plot the data points and color them based on annotations. The function provides various parameters to customize the plot, such as choosing the x and y coordinates, selecting the color scheme, and specifying the point size." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bfbe9eb9", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pl import scatter\n", - "scatter(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "d7390a30", - "metadata": {}, - "source": [ - "**Executed results [Fail]**\n", - "\n", - "Execution failed! Either provide a `basis` or `x` and `y`." - ] - }, - { - "cell_type": "markdown", - "id": "2b4419a2", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pp.normalize_total**\n", - "\n", - "The task is to normalize the data to have a consistent count of 10,000 reads per cell, making the counts comparable among cells. We solved this by using the `scanpy.pp.normalize_total` function, which normalizes each cell by the total counts over all genes. This ensures that every cell has the same total count after normalization." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7fa93ea9", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pp import normalize_total\n", - "normalize_total(result_1, inplace=True)" - ] - }, - { - "cell_type": "markdown", - "id": "7438aa47", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "bba9d9a5", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pp.log1p**\n", - "\n", - "The task is to logarithmize the data matrix, which means taking the natural logarithm of each element in the matrix. We solved it by using the `scanpy.pp.log1p` function, which computes the logarithm of the data matrix by adding 1 to each element and then taking the natural logarithm. The function also allows for specifying a different base for the logarithm if needed." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a8769552", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pp import log1p\n", - "log1p(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "7a5e9c1a", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "50ca8830", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pp.highly_variable_genes**\n", - "\n", - "The task is to identify highly variable genes in a dataset. We solved it by using the `scanpy.pp.highly_variable_genes` function, which annotates the highly variable genes based on different methods such as Seurat and Cell Ranger. The function returns a DataFrame with calculated metrics or updates the dataset with fields indicating highly variable genes." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d951bf5b", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pp import highly_variable_genes\n", - "highly_variable_genes(result_1, inplace=True)" - ] - }, - { - "cell_type": "markdown", - "id": "154233c6", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "efb86e4d", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pl.highly_variable_genes**\n", - "\n", - "The task is to plot dispersions or normalized variance versus means for genes. We solved it by using the `scanpy.pl.highly_variable_genes` function, which produces the desired plot. The function takes parameters such as whether to plot on logarithmic axes and whether to show or save the plot. The function returns a variable with no specific type or description." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "82288866", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pl import highly_variable_genes\n", - "highly_variable_genes(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "f6ed7256", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We visualize the obtained figure" - ] - }, - { - "cell_type": "markdown", - "id": "234b2ef6", - "metadata": {}, - "source": [ - "![Image](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "id": "ca3162dd", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pp.regress_out**\n", - "\n", - "The task is to remove unwanted sources of variation from the data, such as total counts per cell and the percentage of mitochondrial genes expressed, and then scale the data to have the same variance. We solved this by using the `scanpy.pp.regress_out` function, which performs linear regression to remove these unwanted effects. The function takes the data matrix, the keys for observation annotation to regress on, and the number of parallel jobs as parameters, and returns the corrected data matrix." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "79f5d293", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pp import regress_out\n", - "regress_out(result_1, ['total_counts'])" - ] - }, - { - "cell_type": "markdown", - "id": "59131f92", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "92186fab", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pp.scale**\n", - "\n", - "The task is to standardize the data by making its mean zero and variance one. We solved it by using the `scanpy.pp.scale` function, which scales the data to have unit variance and zero mean. The function also handles variables that do not display any variation by setting them to zero." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e88020e6", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pp import scale\n", - "scale(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "982e2bce", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "040d1995", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.tl.pca**\n", - "\n", - "The task is to perform Principal Component Analysis (PCA) on a dataset, which helps to reduce the dimensionality of the data and identify patterns. We solved this task by using the `scanpy.tl.pca` function from the Scanpy library, which implements PCA using the scikit-learn library. The function takes the data matrix as input and returns the PCA coordinates, loadings, and variance decomposition." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f2e3344f", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.tl import pca\n", - "result_2 = pca(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "d6ebe52d", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "Execute success. We didn't obtain new variable" - ] - }, - { - "cell_type": "markdown", - "id": "ae8c2cd4", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pl.pca**\n", - "\n", - "The task is to create a scatter plot in PCA coordinates and annotate the explained variance. We solved it by using the `scanpy.pl.pca` function with the `annotate_var_explained` parameter set to `True`. This function returns a matplotlib axes object that can be used to show or save the plot." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d62fa68c", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pl import pca\n", - "pca(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "1a6fd991", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We visualize the obtained figure" - ] - }, - { - "cell_type": "markdown", - "id": "dfe1abce", - "metadata": {}, - "source": [ - "![Image](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "id": "7e333b07", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pl.pca_variance_ratio**\n", - "\n", - "The task is to plot the variance ratio of the principal components for a given dataset with 10 principal components. We solved it by using the `scanpy.pl.pca_variance_ratio` API function, which plots the variance ratio. The function takes the dataset, the number of principal components to show, and other optional parameters. The function does not return any variable." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8c047ed8", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pl import pca_variance_ratio\n", - "pca_variance_ratio(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "8ef491f9", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We visualize the obtained figure" - ] - }, - { - "cell_type": "markdown", - "id": "b3ce5cdf", - "metadata": {}, - "source": [ - "![Image](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "id": "5b1426c9", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pp.neighbors**\n", - "\n", - "The task is to compute the neighborhood graph of cells using the PCA representation of the data matrix. We solved it by using the `scanpy.pp.neighbors` function, which calculates the neighborhood graph of observations based on the provided data. The function uses either UMAP or Gaussian kernel to estimate the connectivities of data points, and returns the weighted adjacency matrix and distances for each pair of neighbors." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d8a35abb", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pp import neighbors\n", - "neighbors(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "4d352753", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/umap/distances.py:1063: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @numba.jit()\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/umap/distances.py:1071: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @numba.jit()\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/umap/distances.py:1086: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @numba.jit()\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/umap/umap_.py:660: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n", - " @numba.jit()\n" - ] - }, - { - "cell_type": "markdown", - "id": "f177d0eb", - "metadata": {}, - "source": [ - "**Predicted API: embed_umap_paga_graph**\n", - "\n", - "The task is to project the neighborhood graph of a data matrix into two dimensions using UMAP, which helps to visualize the data in a simplified way. We solved this by using the `embed_umap_paga_graph` API function, which takes an annotated data matrix as input and applies UMAP to embed the graph into two dimensions. The function returns an annotated data matrix with the embedded neighborhood graph in two dimensions, making it easier to analyze and understand the data." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "337f0776", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.tl import paga\n", - "paga(result_1)\n", - "from scanpy.pl import paga\n", - "paga(result_1)\n", - "from scanpy.tl import umap\n", - "umap(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "69d5d48c", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "20cad1f6", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pl.umap**\n", - "\n", - "The task is to create a scatter plot using the UMAP basis. We solved it by using the `scanpy.pl.umap` function from the Scanpy library, which takes in the annotated data matrix and the color annotations as parameters. The function returns a matplotlib axes object or a list of axes if multiple components are plotted." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9c7996ad", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pl import umap\n", - "umap(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "3d2e9016", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We visualize the obtained figure" - ] - }, - { - "cell_type": "markdown", - "id": "177463b7", - "metadata": {}, - "source": [ - "![Image](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "id": "6e17e951", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.tl.leiden**\n", - "\n", - "The task is to cluster cells into subgroups using the Leiden algorithm, which is an improved version of the Louvain algorithm. This requires running the `scanpy.tl.leiden` function after performing neighbor calculations on the data. The function returns the subgroup IDs for each cell and a dictionary with the parameter values used for clustering." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cb43230e", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.tl import leiden\n", - "leiden(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "55dccc5e", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "b86f5172", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pl.umap**\n", - "\n", - "The task is to create a scatter plot using the UMAP basis. We solved it by using the `scanpy.pl.umap` function from the Scanpy library, which takes in the annotated data matrix and the color annotations as parameters. The function returns a matplotlib axes object or a list of axes if the plot is not shown." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "38bfb7d1", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pl import umap\n", - "umap(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "99885506", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We visualize the obtained figure" - ] - }, - { - "cell_type": "markdown", - "id": "0a75f3aa", - "metadata": {}, - "source": [ - "![Image](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "id": "4359f3d6", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.tl.rank_genes_groups**\n", - "\n", - "The task is to rank genes for characterizing groups using logarithmized data. We solved it by using the `scanpy.tl.rank_genes_groups` function from the Scanpy library. This function takes in annotated data matrix, groupby key, and other optional parameters, and returns structured arrays and dataframes containing gene names, scores, logfoldchanges, p-values, and other relevant information." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6766adc0", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.tl import rank_genes_groups\n", - "rank_genes_groups(result_1, 'leiden')" - ] - }, - { - "cell_type": "markdown", - "id": "df1c3ea7", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n", - " self.stats[group_name, 'logfoldchanges'] = np.log2(\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n", - " self.stats[group_name, 'logfoldchanges'] = np.log2(\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n", - " self.stats[group_name, 'logfoldchanges'] = np.log2(\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n", - " self.stats[group_name, 'logfoldchanges'] = np.log2(\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n", - " self.stats[group_name, 'logfoldchanges'] = np.log2(\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n", - " self.stats[group_name, 'logfoldchanges'] = np.log2(\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n", - " self.stats[group_name, 'logfoldchanges'] = np.log2(\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n", - " self.stats[group_name, 'logfoldchanges'] = np.log2(\n", - "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n", - " self.stats[group_name, 'logfoldchanges'] = np.log2(\n" - ] - }, - { - "cell_type": "markdown", - "id": "3a68a0a2", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pl.rank_genes_groups**\n", - "\n", - "The task is to plot the ranking of genes based on certain groups in a dataset. We solved it by using the `scanpy.pl.rank_genes_groups` function, which takes in the annotated data matrix, the groups to show the gene ranking for, and other optional parameters such as the number of genes to show and the fontsize for gene names. The function returns a variable with no specific type or description." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bcec3372", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pl import rank_genes_groups\n", - "rank_genes_groups(result_1)" - ] - }, - { - "cell_type": "markdown", - "id": "824b4b54", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We visualize the obtained figure" - ] - }, - { - "cell_type": "markdown", - "id": "36c63160", - "metadata": {}, - "source": [ - "![Image](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "id": "fa807113", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.tl.marker_gene_overlap**\n", - "\n", - "The task is to plot the ranking of genes for all tested comparisons using a list of marker genes. We solved it by using the `scanpy.tl.marker_gene_overlap` function, which calculates the overlap score between data-derived marker genes and provided markers. The function returns a pandas dataframe that can be used to annotate clusters based on marker gene overlaps." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "02f868a5", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.tl import marker_gene_overlap\n", - "marker_gene_overlap(result_1, ['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14','LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1', 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP'], inplace=True)" - ] - }, - { - "cell_type": "markdown", - "id": "84af9f37", - "metadata": {}, - "source": [ - "**Executed results [Fail]**\n", - "\n", - "Execution failed! Writing Pandas dataframes to h5ad is currently under development.\n", - "Please use `inplace=False`." - ] - }, - { - "cell_type": "markdown", - "id": "3ca2eca7", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pl.stacked_violin**\n", - "\n", - "The task is to create a compact violin plot to visualize gene expression per cluster. We solved it by using the `scanpy.pl.stacked_violin` function, which stacks individual violin plots on top of each other. This function provides a convenient way to create the plot and offers flexibility in customizing the visual parameters." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "54e78eb3", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pl import stacked_violin\n", - "stacked_violin(result_1, ['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14','LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1', 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP'], 'leiden')" - ] - }, - { - "cell_type": "markdown", - "id": "b24256e3", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We visualize the obtained figure" - ] - }, - { - "cell_type": "markdown", - "id": "3453991e", - "metadata": {}, - "source": [ - "![Image](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "id": "5d147578", - "metadata": {}, - "source": [ - "**Predicted API: scanpy.pl.dotplot**\n", - "\n", - "The task is to create a dot plot of gene expression values for two genes, `gene1` and `gene2`. We solved it by using the `scanpy.pl.dotplot` function, which plots dots representing the mean expression and fraction of cells expressing the genes for different categories. This allows us to visualize the gene expression across multiple clusters or groups." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a9d44a38", - "metadata": {}, - "outputs": [], - "source": [ - "from scanpy.pl import dotplot\n", - "dotplot(result_1, ['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14','LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1', 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP'], 'leiden')" - ] - }, - { - "cell_type": "markdown", - "id": "2a51b36c", - "metadata": {}, - "source": [ - "**Executed results [Success]**\n", - "\n", - "We visualize the obtained figure" - ] - }, - { - "cell_type": "markdown", - "id": "21c1ff29", - "metadata": {}, - "source": [ - "![Image](data:image/png;base64,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)" - ] - } - ], - "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.13" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/report/demo_Preprocessing_and_clustering_3k_PBMCs.json b/src/report/demo_Preprocessing_and_clustering_3k_PBMCs.json deleted file mode 100644 index 5359986..0000000 --- a/src/report/demo_Preprocessing_and_clustering_3k_PBMCs.json +++ /dev/null @@ -1,2847 +0,0 @@ -{ - "version": 4, - "history": [ - { - "id": "4c78de01-92c6-4ecf-a46b-ddd534934fce", - "name": "Preprocessing and clustering 3k PBMCs", - "method": { - "id": "No specified", - "method": "No specified", - "maxLength": 8000 - }, - "messages": [ - { - "role": "assistant", - "content": "Welcome to BioMANIA! How can I help?", - "tools": [], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "The data consist of 3k PBMCs from a Healthy Donor and are freely available from 10x Genomics. Read in the count matrix into an AnnData object, which holds many slots for annotations and different representations of the data.", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-0", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-0", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Candidate [1]: scanpy.read_10x_h5\nRead 10x-Genomics-formatted hdf5 file.\nCandidate [2]: scanpy.read_visium\nRead 10x-Genomics-formatted visum dataset.\nCandidate [3]: scanpy.read_10x_mtx\nRead 10x-Genomics-formatted mtx directory.", - "task_title": "Can you confirm which of the following 3 candidates", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "3", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-1", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-1", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to read a directory containing files in a specific format used by 10x Genomics. We solved it by using the `scanpy.read_10x_mtx` function, which reads the `.mtx` and `.tsv` files in the directory and returns an `AnnData` object. This object contains the data from the files and can be used for further analysis.", - "task_title": "Predicted API: scanpy.read_10x_mtx", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-2", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-2", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy import read_10x_mtx\nresult_1 = read_10x_mtx('./tmp')", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "We obtain a new AnnData object with n_obs × n_vars = 2700 × 32738\n var: 'gene_ids'", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-4", - "task": "We visualize the first 5 rows of the table data", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "\"\"\nAAACATACAACCAC-1\nAAACATTGAGCTAC-1\nAAACATTGATCAGC-1\nAAACCGTGCTTCCG-1\nAAACCGTGTATGCG-1", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Show those genes that yield the highest fraction of counts in each single cell, across all cells.", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-5", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-5", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to identify the genes that have the highest fraction of counts in each single cell, across all cells. We solved this by using the `scanpy.pl.highest_expr_genes` API function, which calculates the fraction of counts assigned to each gene within a cell and plots the top genes as boxplots. This helps in identifying important genes and potential issues with the data.", - "task_title": "Predicted API: scanpy.pl.highest_expr_genes", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-6", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-6", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pl import highest_expr_genes\nhighest_expr_genes(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "We visualize the obtained figure", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "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", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "filtered out genes that are detected in less than 3 cells", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-8", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-8", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "To filter out genes that are detected in less than 3 cells, you can use the following steps:\n\n1. Calculate the number of cells in which each gene is detected. This can be done by summing the expression values of each gene across all cells.\n\n2. Create a filter based on the number of cells. In this case, you want to keep genes that are detected in at least 3 cells. So, any gene with a count less than 3 should be filtered out.\n\n3. Apply the filter to your gene expression data. This can be done by removing the rows (genes) that do not meet the filter criteria.\n\nHere is an example code snippet in Python using pandas library to perform the filtering:\n\n```python\nimport pandas as pd\n\n# Assuming you have a dataframe called 'gene_expression_data' with genes as rows and cells as columns\n\n# Step 1: Calculate the number of cells in which each gene is detected\ngene_counts = gene_expression_data.sum(axis=1)\n\n# Step 2: Create a filter based on the number of cells\nfilter_criteria = gene_counts >= 3\n\n# Step 3: Apply the filter to your gene expression data\nfiltered_gene_expression_data = gene_expression_data[filter_criteria]\n```\n\nAfter executing this code, the `filtered_gene_expression_data` dataframe will contain only the genes that are detected in at least 3 cells.", - "task_title": "Non API chitchat", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Can you compute quality control metrics for the data?", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-9", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-9", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to compute quality control metrics for a given dataset. We solved it by using the `scanpy.pp.calculate_qc_metrics` function, which calculates various metrics such as the number of genes with positive counts in a cell, the total number of counts for a cell, and the proportion of counts for specific variables. The function returns these metrics as a DataFrame or updates the dataset with the calculated metrics.", - "task_title": "Predicted API: scanpy.pp.calculate_qc_metrics", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-10", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-10", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pp import calculate_qc_metrics\ncalculate_qc_metrics(result_1, inplace=True)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "A violin plot of some of the computed quality measures:\n1. the number of genes expressed in the count matrix\n2. the total counts per cell\n3. the percentage of counts in mitochondrial genes", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-12", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-12", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to create a violin plot showing the number of genes expressed, total counts per cell, and the percentage of counts in mitochondrial genes. We solved it by using the `scanpy.pl.violin` function, which wraps the `seaborn.violinplot` function and allows us to plot these measures using the provided parameters. The function returns a matplotlib axes object that can be used to further customize or save the plot.", - "task_title": "Predicted API: scanpy.pl.violin", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "The predicted API takes Keys for accessing variables of `.var_names` or fields of `.obs`.('keys': Union[str, Sequence[str]]), as input. However, there are still some parameters undefined in the query.", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-14", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-14", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "Which value do you think is appropriate for the parameters 'keys'?", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "['n_genes_by_counts', 'total_counts']", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-15", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-15", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-1", - "task": "from scanpy.pl import violin\nviolin(result_1, ['n_genes_by_counts', 'total_counts'])", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "We visualize the obtained figure", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "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", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Remove cells that have too many mitochondrial genes expressed or too many total counts:", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-18", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-18", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "To remove cells that have too many mitochondrial genes expressed or too many total counts, you can follow these steps:\n\n1. Calculate the total counts for each cell in your dataset. This can be done by summing up the expression values for all genes in each cell.\n\n2. Calculate the number of mitochondrial genes expressed in each cell. You can do this by counting the number of genes in your dataset that are annotated as mitochondrial genes and have non-zero expression values in each cell.\n\n3. Define a threshold for the maximum number of mitochondrial genes expressed or the maximum total counts allowed. This threshold can be determined based on the characteristics of your dataset or by considering the distribution of these values.\n\n4. Create a filter to identify cells that exceed the defined threshold for either the number of mitochondrial genes expressed or the total counts. For example, you can create a logical filter that returns \"True\" for cells that meet the criteria and \"False\" for cells that do not.\n\n5. Apply the filter to your dataset to remove the cells that exceed the threshold. This can be done by subsetting your dataset based on the logical filter.\n\nHere is an example code snippet in Python using the scanpy library to remove cells with too many mitochondrial genes expressed or too many total counts:\n\n```python\nimport scanpy as sc\n\n# Assuming your dataset is stored in an AnnData object called 'adata'\n\n# Calculate total counts for each cell\nadata.obs['total_counts'] = adata.X.sum(axis=1)\n\n# Calculate number of mitochondrial genes expressed in each cell\nmito_genes = adata.var_names.str.startswith('MT-')\nadata.obs['n_mito_genes'] = adata[:, mito_genes].X.sum(axis=1)\n\n# Define thresholds for maximum mitochondrial genes expressed and total counts\nmax_mito_genes = 10\nmax_total_counts = 5000\n\n# Create filter for cells that exceed the thresholds\nfilter_cells = ((adata.obs['n_mito_genes'] <= max_mito_genes) &\n (adata.obs['total_counts'] <= max_total_counts))\n\n# Apply the filter to remove cells that exceed the thresholds\nadata_filtered = adata[filter_cells, :]\n\n# Remove the temporary columns added for calculations\nadata_filtered.obs.drop(['total_counts', 'n_mito_genes'], axis=1, inplace=True)\n```\n\nIn this example, cells with more than 10 mitochondrial genes expressed or more than 5000 total counts will be removed from the dataset. Adjust the threshold values according to your specific requirements.", - "task_title": "Non API chitchat", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Can you create a scatter plot for the data?", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-19", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-19", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to create a scatter plot for the given data. We solved it by using the `scanpy.pl.scatter` function, which allows us to plot the data points and color them based on annotations. The function provides various parameters to customize the plot, such as choosing the x and y coordinates, selecting the color scheme, and specifying the point size.", - "task_title": "Predicted API: scanpy.pl.scatter", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-20", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-20", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pl import scatter\nscatter(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "Execution failed! Either provide a `basis` or `x` and `y`.", - "task_title": "Executed results [Fail]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Total-count normalize (library-size correct) the data to 10,000 reads per cell, so that counts become comparable among cells.", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-22", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-22", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to normalize the data to have a consistent count of 10,000 reads per cell, making the counts comparable among cells. We solved this by using the `scanpy.pp.normalize_total` function, which normalizes each cell by the total counts over all genes. This ensures that every cell has the same total count after normalization.", - "task_title": "Predicted API: scanpy.pp.normalize_total", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-23", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-23", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pp import normalize_total\nnormalize_total(result_1, inplace=True)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Logarithmize the data", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-25", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-25", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to logarithmize the data matrix, which means taking the natural logarithm of each element in the matrix. We solved it by using the `scanpy.pp.log1p` function, which computes the logarithm of the data matrix by adding 1 to each element and then taking the natural logarithm. The function also allows for specifying a different base for the logarithm if needed.", - "task_title": "Predicted API: scanpy.pp.log1p", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-26", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-26", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pp import log1p\nlog1p(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Identify highly-variable genes.\n\n", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-28", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-28", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Candidate [1]: scanpy.pp.highly_variable_genes\nAnnotate highly variable genes [Satija15]_ [Zheng17]_ [Stuart19]_.\nCandidate [2]: scanpy.pl.highly_variable_genes\nPlot dispersions or normalized variance versus means for genes.\nCandidate [3]: scanpy.experimental.pp.highly_variable_genes\nSelect highly variable genes using analytic Pearson residuals [Lause21]_.", - "task_title": "Can you confirm which of the following 3 candidates", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "1", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-29", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-29", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to identify highly variable genes in a dataset. We solved it by using the `scanpy.pp.highly_variable_genes` function, which annotates the highly variable genes based on different methods such as Seurat and Cell Ranger. The function returns a DataFrame with calculated metrics or updates the dataset with fields indicating highly variable genes.", - "task_title": "Predicted API: scanpy.pp.highly_variable_genes", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-30", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-30", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pp import highly_variable_genes\nhighly_variable_genes(result_1, inplace=True)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Identify highly-variable genes.", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-32", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-32", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Candidate [1]: scanpy.pp.highly_variable_genes\nAnnotate highly variable genes [Satija15]_ [Zheng17]_ [Stuart19]_.\nCandidate [2]: scanpy.pl.highly_variable_genes\nPlot dispersions or normalized variance versus means for genes.\nCandidate [3]: scanpy.experimental.pp.highly_variable_genes\nSelect highly variable genes using analytic Pearson residuals [Lause21]_.", - "task_title": "Can you confirm which of the following 3 candidates", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "2", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-33", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-33", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to plot dispersions or normalized variance versus means for genes. We solved it by using the `scanpy.pl.highly_variable_genes` function, which produces the desired plot. The function takes parameters such as whether to plot on logarithmic axes and whether to show or save the plot. The function returns a variable with no specific type or description.", - "task_title": "Predicted API: scanpy.pl.highly_variable_genes", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-34", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-34", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pl import highly_variable_genes\nhighly_variable_genes(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "We visualize the obtained figure", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "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", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Regress out effects of total counts per cell and the percentage of mitochondrial genes expressed. Scale the data to unit variance.", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-36", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-36", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to remove unwanted sources of variation from the data, such as total counts per cell and the percentage of mitochondrial genes expressed, and then scale the data to have the same variance. We solved this by using the `scanpy.pp.regress_out` function, which performs linear regression to remove these unwanted effects. The function takes the data matrix, the keys for observation annotation to regress on, and the number of parallel jobs as parameters, and returns the corrected data matrix.", - "task_title": "Predicted API: scanpy.pp.regress_out", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "The predicted API takes Keys for observation annotation on which to regress on.('keys': Union[str, Sequence[str]]), as input. However, there are still some parameters undefined in the query.", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-38", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-38", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "Which value do you think is appropriate for the parameters 'keys'?", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "['total_counts']", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-39", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-39", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-1", - "task": "from scanpy.pp import regress_out\nregress_out(result_1, ['total_counts'])", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Can you standardize the data to have zero mean and unit variance?", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-41", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-41", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to standardize the data by making its mean zero and variance one. We solved it by using the `scanpy.pp.scale` function, which scales the data to have unit variance and zero mean. The function also handles variables that do not display any variation by setting them to zero.", - "task_title": "Predicted API: scanpy.pp.scale", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-42", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-42", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pp import scale\nscale(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Reduce the dimensionality of the data by running principal component analysis (PCA), which reveals the main axes of variation and denoises the data.", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-44", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-44", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Candidate [1]: scanpy.tl.pca\nPrincipal component analysis [Pedregosa11]_.\nCandidate [2]: scanpy.pl.pca\nScatter plot in PCA coordinates.\nCandidate [3]: scanpy.pp.pca\nPrincipal component analysis [Pedregosa11]_.", - "task_title": "Can you confirm which of the following 3 candidates", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "1", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-45", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-45", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to perform Principal Component Analysis (PCA) on a dataset, which helps to reduce the dimensionality of the data and identify patterns. We solved this task by using the `scanpy.tl.pca` function from the Scanpy library, which implements PCA using the scikit-learn library. The function takes the data matrix as input and returns the PCA coordinates, loadings, and variance decomposition.", - "task_title": "Predicted API: scanpy.tl.pca", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-46", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-46", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.tl import pca\nresult_2 = pca(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "Execute success. We didn't obtain new variable", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "We can make a scatter plot in the PCA coordinates", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-48", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-48", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Candidate [1]: scanpy.tl.pca\nPrincipal component analysis [Pedregosa11]_.\nCandidate [2]: scanpy.pl.pca\nScatter plot in PCA coordinates.\nCandidate [3]: scanpy.pp.pca\nPrincipal component analysis [Pedregosa11]_.", - "task_title": "Can you confirm which of the following 3 candidates", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "2", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-49", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-49", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to create a scatter plot in PCA coordinates and annotate the explained variance. We solved it by using the `scanpy.pl.pca` function with the `annotate_var_explained` parameter set to `True`. This function returns a matplotlib axes object that can be used to show or save the plot.", - "task_title": "Predicted API: scanpy.pl.pca", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-50", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-50", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pl import pca\npca(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "We visualize the obtained figure", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "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", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Can you plot the variance ratio of the principal components for this data with 10 principal components?", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-52", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-52", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to plot the variance ratio of the principal components for a given dataset with 10 principal components. We solved it by using the `scanpy.pl.pca_variance_ratio` API function, which plots the variance ratio. The function takes the dataset, the number of principal components to show, and other optional parameters. The function does not return any variable.", - "task_title": "Predicted API: scanpy.pl.pca_variance_ratio", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-53", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-53", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pl import pca_variance_ratio\npca_variance_ratio(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "We visualize the obtained figure", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "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", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Let us compute the neighborhood graph of cells using the PCA representation of the data matrix. ", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-55", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-55", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to compute the neighborhood graph of cells using the PCA representation of the data matrix. We solved it by using the `scanpy.pp.neighbors` function, which calculates the neighborhood graph of observations based on the provided data. The function uses either UMAP or Gaussian kernel to estimate the connectivities of data points, and returns the weighted adjacency matrix and distances for each pair of neighbors.", - "task_title": "Predicted API: scanpy.pp.neighbors", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-56", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-56", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pp import neighbors\nneighbors(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/umap/distances.py:1063: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n @numba.jit()\n/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/umap/distances.py:1071: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n @numba.jit()\n/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/umap/distances.py:1086: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n @numba.jit()\n/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/umap/umap_.py:660: NumbaDeprecationWarning: \u001b[1mThe 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\u001b[0m\n @numba.jit()\n", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Can you project the neighborhood graph of the annotated data matrix into 2 dimensions using UMAP?", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-66", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-66", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to project the neighborhood graph of a data matrix into two dimensions using UMAP, which helps to visualize the data in a simplified way. We solved this by using the `embed_umap_paga_graph` API function, which takes an annotated data matrix as input and applies UMAP to embed the graph into two dimensions. The function returns an annotated data matrix with the embedded neighborhood graph in two dimensions, making it easier to analyze and understand the data.", - "task_title": "Predicted API: embed_umap_paga_graph", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-67", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-67", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.tl import paga\npaga(result_1)\nfrom scanpy.pl import paga\npaga(result_1)\nfrom scanpy.tl import umap\numap(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "We suggest embedding the graph in two dimensions using UMAP (McInnes et al., 2018)", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-69", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-69", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Candidate [1]: scanpy.pl.umap\nScatter plot in UMAP basis.\nCandidate [2]: scanpy.tl.umap\nEmbed the neighborhood graph using UMAP [McInnes18]_.", - "task_title": "Can you confirm which of the following 2 candidates", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "1", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-70", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-70", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to create a scatter plot using the UMAP basis. We solved it by using the `scanpy.pl.umap` function from the Scanpy library, which takes in the annotated data matrix and the color annotations as parameters. The function returns a matplotlib axes object or a list of axes if multiple components are plotted.", - "task_title": "Predicted API: scanpy.pl.umap", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-71", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-71", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pl import umap\numap(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "We visualize the obtained figure", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "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", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "As with Seurat and many other frameworks, we recommend the Leiden graph-clustering method (community detection based on optimizing modularity) by Traag et al. (2018)", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-73", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-73", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Candidate [1]: scanpy.tl.leiden\nCluster cells into subgroups [Traag18]_.\nCandidate [2]: scanpy.tl.louvain\nCluster cells into subgroups [Blondel08]_ [Levine15]_ [Traag17]_.", - "task_title": "Can you confirm which of the following 2 candidates", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "1", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-74", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-74", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to cluster cells into subgroups using the Leiden algorithm, which is an improved version of the Louvain algorithm. This requires running the `scanpy.tl.leiden` function after performing neighbor calculations on the data. The function returns the subgroup IDs for each cell and a dictionary with the parameter values used for clustering.", - "task_title": "Predicted API: scanpy.tl.leiden", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-75", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-75", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.tl import leiden\nleiden(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Visualize a scatter plot in UMAP basis with arrows and groups using the provided annotated data matrix.", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-81", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-81", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Candidate [1]: scanpy.pl.umap\nScatter plot in UMAP basis.\nCandidate [2]: scanpy.tl.umap\nEmbed the neighborhood graph using UMAP [McInnes18]_.", - "task_title": "Can you confirm which of the following 2 candidates", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "1", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-82", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-82", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to create a scatter plot using the UMAP basis. We solved it by using the `scanpy.pl.umap` function from the Scanpy library, which takes in the annotated data matrix and the color annotations as parameters. The function returns a matplotlib axes object or a list of axes if the plot is not shown.", - "task_title": "Predicted API: scanpy.pl.umap", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-83", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-83", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pl import umap\numap(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "We visualize the obtained figure", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "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", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Let us compute a ranking for the highly differential genes in each cluster.\n", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-91", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-91", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Candidate [1]: scanpy.pl.rank_genes_groups\nPlot ranking of genes.\nCandidate [2]: scanpy.tl.rank_genes_groups\nRank genes for characterizing groups.", - "task_title": "Can you confirm which of the following 2 candidates", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "2", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-92", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-92", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to rank genes for characterizing groups using logarithmized data. We solved it by using the `scanpy.tl.rank_genes_groups` function from the Scanpy library. This function takes in annotated data matrix, groupby key, and other optional parameters, and returns structured arrays and dataframes containing gene names, scores, logfoldchanges, p-values, and other relevant information.", - "task_title": "Predicted API: scanpy.tl.rank_genes_groups", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "The predicted API takes The key of the observations grouping to consider.('groupby': str), as input. However, there are still some parameters undefined in the query.", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-94", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-94", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "Which value do you think is appropriate for the parameters 'groupby'?", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "leiden", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-95", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-95", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-1", - "task": "from scanpy.tl import rank_genes_groups\nrank_genes_groups(result_1, 'leiden')", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n self.stats[group_name, 'logfoldchanges'] = np.log2(\n/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n self.stats[group_name, 'logfoldchanges'] = np.log2(\n/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n self.stats[group_name, 'logfoldchanges'] = np.log2(\n/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n self.stats[group_name, 'logfoldchanges'] = np.log2(\n/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n self.stats[group_name, 'logfoldchanges'] = np.log2(\n/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n self.stats[group_name, 'logfoldchanges'] = np.log2(\n/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n self.stats[group_name, 'logfoldchanges'] = np.log2(\n/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n self.stats[group_name, 'logfoldchanges'] = np.log2(\n/home/z6dong/anaconda3/envs/py310/lib/python3.10/site-packages/scanpy/tools/_rank_genes_groups.py:422: RuntimeWarning: invalid value encountered in log2\n self.stats[group_name, 'logfoldchanges'] = np.log2(\n", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Let us compute a ranking for the highly differential genes in each cluster.", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-97", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-97", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Candidate [1]: scanpy.pl.rank_genes_groups\nPlot ranking of genes.\nCandidate [2]: scanpy.tl.rank_genes_groups\nRank genes for characterizing groups.", - "task_title": "Can you confirm which of the following 2 candidates", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "1", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-98", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-98", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to plot the ranking of genes based on certain groups in a dataset. We solved it by using the `scanpy.pl.rank_genes_groups` function, which takes in the annotated data matrix, the groups to show the gene ranking for, and other optional parameters such as the number of genes to show and the fontsize for gene names. The function returns a variable with no specific type or description.", - "task_title": "Predicted API: scanpy.pl.rank_genes_groups", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-99", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-99", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-2", - "task": "from scanpy.pl import rank_genes_groups\nrank_genes_groups(result_1)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "We visualize the obtained figure", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "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", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Let us also define a list of marker genes for later reference.\nmarker_genes = ['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14',\n 'LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1',\n 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP']\nPlot the ranking of genes for all tested comparisons using the provided genes from the data.", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-101", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-101", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to plot the ranking of genes for all tested comparisons using a list of marker genes. We solved it by using the `scanpy.tl.marker_gene_overlap` function, which calculates the overlap score between data-derived marker genes and provided markers. The function returns a pandas dataframe that can be used to annotate clusters based on marker gene overlaps.", - "task_title": "Predicted API: scanpy.tl.marker_gene_overlap", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "The predicted API takes A marker gene dictionary object. Keys should be strings with the\ncell identity name and values are sets or lists of strings which match\nformat of `adata.var_name`.('reference_markers': Union[Dict[str, set], Dict[str, list]]), as input. However, there are still some parameters undefined in the query.", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-103", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-103", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "Which value do you think is appropriate for the parameters 'reference_markers'?", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14','LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1', 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP']", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-104", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-104", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-1", - "task": "from scanpy.tl import marker_gene_overlap\nmarker_gene_overlap(result_1, ['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14','LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1', 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP'], inplace=True)", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "Execution failed! Writing Pandas dataframes to h5ad is currently under development.\nPlease use `inplace=False`.", - "task_title": "Executed results [Fail]", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Please visualize using compact violin plot", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-106", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-106", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to create a compact violin plot to visualize gene expression per cluster. We solved it by using the `scanpy.pl.stacked_violin` function, which stacks individual violin plots on top of each other. This function provides a convenient way to create the plot and offers flexibility in customizing the visual parameters.", - "task_title": "Predicted API: scanpy.pl.stacked_violin", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "The predicted API takes `var_names` should be a valid subset of `adata.var_names`.\nIf `var_names` is a mapping, then the key is used as label\nto group the values (see `var_group_labels`). The mapping values\nshould be sequences of valid `adata.var_names`. In this\ncase either coloring or 'brackets' are used for the grouping\nof var names depending on the plot. When `var_names` is a mapping,\nthen the `var_group_labels` and `var_group_positions` are set.('var_names': Union[str, Sequence[str], Mapping[str, Union[str, Sequence[str]]]]), and The key of the observation grouping to consider.('groupby': Union[str, Sequence[str]]), as input. However, there are still some parameters undefined in the query.", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-108", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-108", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "Which value do you think is appropriate for the parameters 'var_names'?", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14','LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1', 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP']", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-109", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-109", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Which value do you think is appropriate for the parameters 'groupby'?", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "leiden", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-110", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-110", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-1", - "task": "from scanpy.pl import stacked_violin\nstacked_violin(result_1, ['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14','LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1', 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP'], 'leiden')", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "We visualize the obtained figure", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "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", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "Can you create a dot plot of gene expression values for two genes, `gene1` and `gene2`?", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-114", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-114", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "The task is to create a dot plot of gene expression values for two genes, `gene1` and `gene2`. We solved it by using the `scanpy.pl.dotplot` function, which plots dots representing the mean expression and fraction of cells expressing the genes for different categories. This allows us to visualize the gene expression across multiple clusters or groups.", - "task_title": "Predicted API: scanpy.pl.dotplot", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "The predicted API takes `var_names` should be a valid subset of `adata.var_names`.\nIf `var_names` is a mapping, then the key is used as label\nto group the values (see `var_group_labels`). The mapping values\nshould be sequences of valid `adata.var_names`. In this\ncase either coloring or 'brackets' are used for the grouping\nof var names depending on the plot. When `var_names` is a mapping,\nthen the `var_group_labels` and `var_group_positions` are set.('var_names': Union[str, Sequence[str], Mapping[str, Union[str, Sequence[str]]]]), and The key of the observation grouping to consider.('groupby': Union[str, Sequence[str]]), as input. However, there are still some parameters undefined in the query.", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - }, - { - "method_name": "on_tool_start", - "block_id": "tool-116", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-116", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-3", - "task": "Which value do you think is appropriate for the parameters 'var_names'?", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14','LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1', 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP']", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-117", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-117", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "log-1", - "task": "Which value do you think is appropriate for the parameters 'groupby'?", - "task_title": "Enter Parameters: basic type", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "red" - } - ], - "recommendations": [], - "files": [] - }, - { - "role": "user", - "content": "leiden", - "tools": [], - "recommendations": [], - "files": [], - "conversation_started": false - }, - { - "role": "assistant", - "content": "", - "tools": [ - { - "method_name": "on_tool_start", - "block_id": "tool-118", - "api_name": "", - "api_description": "", - "api_calling": "", - "depth": 0 - }, - { - "method_name": "on_tool_end", - "block_id": "tool-118", - "task": "put variable from user input to parameters", - "status": "0", - "depth": 0 - }, - { - "method_name": "on_agent_action", - "block_id": "code-1", - "task": "from scanpy.pl import dotplot\ndotplot(result_1, ['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14','LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1', 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP'], 'leiden')", - "task_title": "Executed code", - "composite_code": "", - "imageData": "", - "tableData": "", - "depth": 0, - "color": "black" - }, - { - "method_name": "on_agent_action", - "block_id": "log-2", - "task": "We visualize the obtained figure", - "task_title": "Executed results [Success]", - "composite_code": "", - "imageData": "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", - "tableData": "", - "depth": 0, - "color": "black" - } - ], - "recommendations": [], - "files": [] - } - ], - "top_k": 1, - "folderId": null, - "Lib": "scanpy", - "files": [], - "new_lib_github_url": "", - "new_lib_doc_url": "", - "api_html": "", - "lib_alias": "", - "conversation_started": true - } - ], - "folders": [], - "prompts": [] -} \ No newline at end of file diff --git a/src/report/demo_Preprocessing_and_clustering_3k_PBMCs.py b/src/report/demo_Preprocessing_and_clustering_3k_PBMCs.py deleted file mode 100644 index a3a91b0..0000000 --- a/src/report/demo_Preprocessing_and_clustering_3k_PBMCs.py +++ /dev/null @@ -1,46 +0,0 @@ -from scanpy import read_10x_mtx -result_1 = read_10x_mtx('./tmp') -from scanpy.pl import highest_expr_genes -highest_expr_genes(result_1) -from scanpy.pp import calculate_qc_metrics -calculate_qc_metrics(result_1, inplace=True) -from scanpy.pl import violin -violin(result_1, ['n_genes_by_counts', 'total_counts']) -from scanpy.pp import normalize_total -normalize_total(result_1, inplace=True) -from scanpy.pp import log1p -log1p(result_1) -from scanpy.pp import highly_variable_genes -highly_variable_genes(result_1, inplace=True) -from scanpy.pl import highly_variable_genes -highly_variable_genes(result_1) -from scanpy.pp import regress_out -regress_out(result_1, ['total_counts']) -from scanpy.pp import scale -scale(result_1) -from scanpy.tl import pca -result_2 = pca(result_1) -from scanpy.pl import pca -pca(result_1) -from scanpy.pl import pca_variance_ratio -pca_variance_ratio(result_1) -from scanpy.pp import neighbors -neighbors(result_1) -from scanpy.tl import paga -paga(result_1) -from scanpy.pl import paga -paga(result_1) -from scanpy.tl import umap -umap(result_1) -from scanpy.pl import umap -umap(result_1) -from scanpy.tl import leiden -leiden(result_1) -from scanpy.tl import rank_genes_groups -rank_genes_groups(result_1, 'leiden') -from scanpy.pl import rank_genes_groups -rank_genes_groups(result_1) -from scanpy.pl import stacked_violin -stacked_violin(result_1, ['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14','LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1', 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP'], 'leiden') -from scanpy.pl import dotplot -dotplot(result_1, ['IL7R', 'CD79A', 'MS4A1', 'CD8A', 'CD8B', 'LYZ', 'CD14','LGALS3', 'S100A8', 'GNLY', 'NKG7', 'KLRB1', 'FCGR3A', 'MS4A7', 'FCER1A', 'CST3', 'PPBP'], 'leiden') \ No newline at end of file