From 3fcacb46c9bc133b12175f706613d62633ebd638 Mon Sep 17 00:00:00 2001 From: ejiawustl <89940465+ejiawustl@users.noreply.github.com> Date: Wed, 28 Aug 2024 11:43:12 -0700 Subject: [PATCH] Processing data tutorial (#104) * adding perturbation response relationship tutorial * addressed the changes to the notebook: added analysis to all graphs, typehinting and docstrings to methods, and other misc changes * added new methods and analysis to enable comparison between different dataset combinations. Added everything under the last subtitle, with each section having smaller subheadings underneath to group everything * Calculate variance explained (#88) * fixed adjustment function so its based on enrichment strength * added new file util.py and new test suite and updated notebook * Update pyproject.toml This is already in the dev dependencies. I forgot to go over that. To add 'production' depdencies with python, you add to the default dependencies section with just: ``` poetry add ``` You can also add dependencies to a group, eg: ``` poetry add --group dev ``` See https://python-poetry.org/docs/cli/#options-4 That way, you can control what dependencies get installed. For a typical user, I don't think we'll want to install jupyter in the environment. They should have jupyter in their environment, and then install yeastdnnexplorer into it. * parameterizing the max_adjustment value and adding the calculate_variance_explained function and test suite * removing the function and test suite for calculating the variance explained and adding the function to the visualizing_and_testing_data_generation_methods notebook * Added docstrings and typehinting, removed unnecessary work and added exposition to graphs and methods * updated notebook to use sphinx docstrings, added headings and subheadings and improved exposition --------- Co-authored-by: Eric Jia Co-authored-by: Chase Mateusiak * fixed adjustment function so its based on enrichment strength (#86) Co-authored-by: Eric Jia * Database Interface (#90) * adding new file for explanation * adding ParamsDict * init implementation of the API classes. Documentation and some testing included. RankResponse is not, and the testing is minimal due to the difficulty of testing futures * adding some words to the project ignore settings * rank response api working * addressing unused imports in RankResponseAPI * updating the database_interface notebook for the new database backend; addressing logging warning on instantiation * updating the tutorial to show how to use the aggregated data (#91) * table data retrieved as gzip; addtiional columns now present from DB * Update README.md closes #81 * Adding update to manualqc (#96) * removing new file, part of a demo * adding update() method to bindingmanualqc; added _delimiter_detect method to AbstractRecords * addressing pre-commit issues * This is getting the dev branch rebased onto the main branch (#100) * Calculate variance explained (#88) * fixed adjustment function so its based on enrichment strength * added new file util.py and new test suite and updated notebook * Update pyproject.toml This is already in the dev dependencies. I forgot to go over that. To add 'production' depdencies with python, you add to the default dependencies section with just: ``` poetry add ``` You can also add dependencies to a group, eg: ``` poetry add --group dev ``` See https://python-poetry.org/docs/cli/#options-4 That way, you can control what dependencies get installed. For a typical user, I don't think we'll want to install jupyter in the environment. They should have jupyter in their environment, and then install yeastdnnexplorer into it. * parameterizing the max_adjustment value and adding the calculate_variance_explained function and test suite * removing the function and test suite for calculating the variance explained and adding the function to the visualizing_and_testing_data_generation_methods notebook * Added docstrings and typehinting, removed unnecessary work and added exposition to graphs and methods * updated notebook to use sphinx docstrings, added headings and subheadings and improved exposition --------- Co-authored-by: Eric Jia Co-authored-by: Chase Mateusiak * fixed adjustment function so its based on enrichment strength (#86) Co-authored-by: Eric Jia * Database Interface (#90) * adding new file for explanation * adding ParamsDict * init implementation of the API classes. Documentation and some testing included. RankResponse is not, and the testing is minimal due to the difficulty of testing futures * adding some words to the project ignore settings * rank response api working * addressing unused imports in RankResponseAPI * updating the database_interface notebook for the new database backend; addressing logging warning on instantiation * updating the tutorial to show how to use the aggregated data (#91) * table data retrieved as gzip; addtiional columns now present from DB * Update README.md closes #81 * Adding update to manualqc (#96) * removing new file, part of a demo * adding update() method to bindingmanualqc; added _delimiter_detect method to AbstractRecords * addressing pre-commit issues --------- Co-authored-by: ejiawustl <89940465+ejiawustl@users.noreply.github.com> Co-authored-by: Eric Jia * Add branch protection CI to prevent pulls directly to main (#101) This should only allow pulls from a branch called `dev` or `patch` directly to main. otherwise, pull requests will be required to be against `dev` * fixed adjustment function so its based on enrichment strength (#86) Co-authored-by: Eric Jia * adding perturbation response relationship tutorial * addressed the changes to the notebook: added analysis to all graphs, typehinting and docstrings to methods, and other misc changes * added new methods and analysis to enable comparison between different dataset combinations. Added everything under the last subtitle, with each section having smaller subheadings underneath to group everything * added docstring and typehinting to all methods, and added exposition to better explain the different conditions we use the model in. TODO: need to hide some of the output when training models or create an issue if I am unable to do so. * Update exploring_perturbation_response_relationship notebook, still WIP * adding notebook, new pyproject * updated notebook: including a lot of new things based on the research work we have been doing for the last month. This notebook currently ends with a guide on creating the linear models on the cluster, but I can include more recent work involving the correlations and models we have been experimenting with * went through all notebooks in vim and resolved merges by keeping the current changes * adding statsmodels to pyproject --------- Co-authored-by: Eric Jia Co-authored-by: Chase Mateusiak Co-authored-by: Chase Mateusiak --- .gitignore | 5 +- docs/tutorials/database_interface.ipynb | 6 +- ...g_perturbation_response_relationship.ipynb | 4260 +++++++++++++++++ docs/tutorials/generate_in_silico_data.ipynb | 1 - ..._and_testing_data_generation_methods.ipynb | 850 +++- pyproject.toml | 1 + 6 files changed, 4959 insertions(+), 164 deletions(-) create mode 100644 docs/tutorials/exploring_perturbation_response_relationship.ipynb diff --git a/.gitignore b/.gitignore index f632909..3eeb70f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,11 @@ +#mac files +**/.DS_Store + # Dataset directory data/ # logs -logs/ +**/logs/ # local tmp files tmp/* diff --git a/docs/tutorials/database_interface.ipynb b/docs/tutorials/database_interface.ipynb index b7459e2..429f511 100644 --- a/docs/tutorials/database_interface.ipynb +++ b/docs/tutorials/database_interface.ipynb @@ -2142,7 +2142,7 @@ ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -2156,9 +2156,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.1" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/docs/tutorials/exploring_perturbation_response_relationship.ipynb b/docs/tutorials/exploring_perturbation_response_relationship.ipynb new file mode 100644 index 0000000..9b50f1f --- /dev/null +++ b/docs/tutorials/exploring_perturbation_response_relationship.ipynb @@ -0,0 +1,4260 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5b629869-1925-4ab5-8369-364aa66c2313", + "metadata": {}, + "source": [ + "# **Visualizing Relationship Between Binding and Perturbation Response**\n", + "\n", + "This tutorial walks you through the methods and approaches taken to process the data and visualize trends within the data in regard to the binding and perturbation effects of TFs on genes in preparation for model training." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "8dfc7cab-ff5d-4575-b380-8b1a04a5b435", + "metadata": {}, + "outputs": [], + "source": [ + "#imports \n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "from scipy.stats import rankdata, pearsonr\n", + "import asyncio\n", + "import nest_asyncio\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from yeastdnnexplorer.interface import *\n", + "nest_asyncio.apply()\n", + "from typing import List, Optional\n", + "import warnings\n", + "from patsy import dmatrices, dmatrix, demo_data" + ] + }, + { + "cell_type": "markdown", + "id": "055099e6-8abf-4b73-9371-c0fba30fce2e", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## **Accessing combined TF data**" + ] + }, + { + "cell_type": "markdown", + "id": "39e387cf-e559-4a1c-83c2-e88180eb1187", + "metadata": {}, + "source": [ + "The cell below displays the first 3 TFs that contain aggregated Calling Cards binding data in the database. You can modify the command to return the entire list of TFs that contain aggregated data if needed. This code is mostly taken from the database_interface tutorial, refer to it if needed for more information on how to use the database. " + ] + }, + { + "cell_type": "code", + "execution_count": 240, + "id": "92b6af43-10eb-4c48-9e4d-9554326ba903", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 WTM1\n", + "1 MIG2\n", + "2 CAT8\n", + "Name: regulator_symbol, dtype: object\n", + "Total number of TFs with aggregated data: 71\n" + ] + } + ], + "source": [ + "pss_api = PromoterSetSigAPI()\n", + "\n", + "pss_api.push_params({\"datasource\": \"brent_nf_cc\", \"aggregated\": \"true\"})\n", + "\n", + "callingcards_aggregated_meta_res = await pss_api.read()\n", + "\n", + "callingcards_aggregated_meta_df = callingcards_aggregated_meta_res.get(\"metadata\")\n", + "\n", + "# Prints the first 3 TFs that have aggregated data available. Modify as necessary to see the whole list of TFs\n", + "print(callingcards_aggregated_meta_df[\"regulator_symbol\"][:3])\n", + "\n", + "# Prints the total number of TFs that have aggregated data available.\n", + "print(\"Total number of TFs with aggregated data: \"+ str(len(callingcards_aggregated_meta_df[\"regulator_symbol\"])))" + ] + }, + { + "cell_type": "markdown", + "id": "03ffc72a-2963-43ad-bcd4-83d734a560ba", + "metadata": {}, + "source": [ + "#### Code\n", + "Given the length of the methods below, it is optimal to hide the cells after running them to ensure readability of the notebook. " + ] + }, + { + "cell_type": "markdown", + "id": "27e42e1f-3224-4e37-bf7f-b7019358665c", + "metadata": {}, + "source": [ + "This method asynchronously retrieves and processes data for a given transcription factor. It combines the desired binding and perturbation data for the chosen TF and returns a DataFrame containing both the binding and perturbation data which we will use for further analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "1eca9111-501c-484d-af3c-344462f1d553", + "metadata": {}, + "outputs": [], + "source": [ + "#TODO: add a test for this method for future integration into the source code\n", + "\n", + "async def process_transcription_factor_async(tf_name: str, is_aggregated: bool, binding_source: str, perturbation_source: str, pseudocount: int = 1) -> pd.DataFrame: \n", + " \"\"\"\n", + " Process transcription factor data by retrieving and merging binding and perturbation datasets.\n", + "\n", + " :param tf_name: The name of the transcription factor, e.g., \"AR080\".\n", + " :type tf_name: str\n", + " :param is_aggregated: Indicates whether the data is aggregated.\n", + " :type is_aggregated: bool\n", + " :param binding_source: The source of the binding data, e.g., \"cc\" or \"harbison\".\n", + " :type binding_source: str\n", + " :param perturbation_source: The source of the perturbation data, e.g., \"mcisaac\".\n", + " :type perturbation_source: str\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: int, optional\n", + "\n", + " :returns: A DataFrame containing the combined and processed binding and perturbation data.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " # Ensure the TF name is in uppercase to maintain consistency\n", + " tf_name_upper = tf_name.upper()\n", + " \n", + " # Initialize API for binding data\n", + " pss_api_tf = PromoterSetSigAPI()\n", + "\n", + " # Access the relevant data depending on the binding source and aggregation status\n", + " if binding_source == \"cc\":\n", + " if is_aggregated:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"datasource\": \"brent_nf_cc\", \"aggregated\": \"true\"})\n", + " else:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"workflow\": \"nf_core_callingcards_1_0_0\", \"data_usable\": \"pass\"})\n", + " elif binding_source == \"harbison\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"4\"})\n", + " elif binding_source == \"mitra\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"2\"})\n", + " elif binding_source == \"chip_exo\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"3\"})\n", + "\n", + " # Asynchronously read the binding data from the API\n", + " tf_pss = await pss_api_tf.read(retrieve_files=True)\n", + " # Get the ID of the retrieved binding data\n", + " id = tf_pss.get(\"metadata\")[\"id\"][0]\n", + " # Extract the binding data using the ID\n", + " binding_df = tf_pss.get(\"data\").get(str(id))\n", + "\n", + " # Initialize API for perturbation data\n", + " expression = ExpressionAPI()\n", + "\n", + " # Map perturbation source to corresponding source number\n", + " source_mapping = {\n", + " \"mcisaac\": \"7\",\n", + " \"hu_reimann\": \"5\",\n", + " \"kemmeren\": \"6\"\n", + " }\n", + " source_number = source_mapping.get(perturbation_source, \"unknown\")\n", + " \n", + " # Push parameters to retrieve the perturbation data\n", + " if perturbation_source == \"mcisaac\":\n", + " expression.push_params({\"regulator_symbol\": tf_name_upper, \"source\": source_number, \"time\": \"15\"})\n", + " else:\n", + " expression.push_params({\"regulator_symbol\": tf_name_upper, \"source\": source_number})\n", + "\n", + " # Asynchronously read the perturbation data from the API\n", + " expression_res = await expression.read(retrieve_files=True)\n", + " # Get the ID of the retrieved perturbation data\n", + " id = expression_res.get(\"metadata\")[\"id\"][0]\n", + " # Extract the perturbation data using the ID\n", + " expression_df = expression_res.get(\"data\").get(str(id))\n", + "\n", + " # Read perturbation data\n", + " perturbation_data = expression_df\n", + " # Read binding data\n", + " binding_data = binding_df\n", + "\n", + " # Rename columns in binding data for consistency and clarity\n", + " if binding_source == \"cc\":\n", + " binding_data.rename(columns={\"callingcards_enrichment\": \"effect\", \"poisson_pval\": \"pvalue\"}, inplace=True)\n", + " elif binding_source == \"harbison\":\n", + " binding_data.rename(columns={\"pval\": \"pvalue\"}, inplace=True)\n", + " elif binding_source == \"mitra\":\n", + " binding_data.rename(columns={\"callingcards_enrichment\": \"effect\", \"poisson_pval\": \"pvalue\"}, inplace=True)\n", + " elif binding_source == \"chip_exo\":\n", + " binding_data.rename(columns={\"max_fc\": \"effect\", \"min_pval\": \"pvalue\"}, inplace=True)\n", + "\n", + " # Optional: here you can modify the pseudocount as needed. The default pseudocount is set to 1.\n", + " # Calculate the effect size for binding data using the provided formula\n", + " if binding_source == \"cc\":\n", + " binding_data['effect'] = (binding_data['experiment_hops'] / binding_data['experiment_total_hops']) / \\\n", + " ((binding_data['background_hops'] + pseudocount) / binding_data['background_total_hops'])\n", + "\n", + " # Merge the binding data and perturbation data on the 'target_locus_tag' column\n", + " combined_data = pd.merge(binding_data, perturbation_data, on='target_locus_tag', suffixes=('_binding', '_perturbation'))\n", + "\n", + " # # Assert that the length of combined_data is the minimum of the lengths of binding_data and perturbation_data\n", + " # assert len(combined_data) <= min(len(binding_data), len(perturbation_data)), \\\n", + " # f\"Length of combined_data ({len(combined_data)}) is not equal to the minimum of lengths of binding_data ({len(binding_data)}) and perturbation_data ({len(perturbation_data)})\"\n", + "\n", + " # Keep only the necessary columns in the combined data\n", + " combined_data = combined_data[['target_locus_tag', 'effect_binding', 'effect_perturbation', 'pvalue_binding']]\n", + "\n", + " # Reorder the combined data by the smallest 'pvalue_binding' values\n", + " combined_data = combined_data.sort_values(by='pvalue_binding')\n", + "\n", + " # Apply transformations:\n", + " # - Take the absolute value of 'effect_perturbation'\n", + " # - Calculate the negative log10 of 'pvalue_binding'\n", + " # - Calculate the log10 of 'effect_binding'\n", + " combined_data['effect_perturbation'] = combined_data['effect_perturbation'].abs()\n", + " combined_data['neg_log_pvalue_binding'] = -np.log10(combined_data['pvalue_binding'])\n", + " combined_data['log_enrichment'] = np.log10(combined_data['effect_binding'])\n", + "\n", + " # Return the processed combined data as a DataFrame\n", + " return combined_data" + ] + }, + { + "cell_type": "markdown", + "id": "fd7ffe4b-3515-41c0-a245-9d5b8cd607c5", + "metadata": {}, + "source": [ + "The process_transcription_factor method below is used to call the asynchronous process_transcription_factor_async function above in a way that works with regular, step-by-step code. We need this function to use the method above in loops or other structures that don’t handle asynchronous functions well." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "0b1b7780-6e25-4530-b304-4fb71c015131", + "metadata": {}, + "outputs": [], + "source": [ + "def process_transcription_factor(tf_name: str, is_aggregated: bool, binding_source: str, perturbation_data: str, pseudocount: int = 1) -> pd.DataFrame:\n", + " \"\"\"\n", + " Processes transcription factor data synchronously by invoking an asynchronous function.\n", + " \n", + " This function runs the asynchronous `process_transcription_factor_async` function synchronously to handle \n", + " transcription factor data processing. It retrieves the event loop, runs the asynchronous function, \n", + " and returns the processed DataFrame.\n", + " \n", + " :param tf_name: The name of the transcription factor.\n", + " :type tf_name: str\n", + " :param is_aggregated: A boolean flag indicating whether the data is aggregated.\n", + " :type is_aggregated: bool\n", + " :param perturbation_source: The source of the perturbation data.\n", + " :type perturbation_source: str\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: int, optional\n", + " \n", + " :returns: A DataFrame containing the processed transcription factor data.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n", + " \n", + " loop = asyncio.get_event_loop()\n", + " return loop.run_until_complete(process_transcription_factor_async(tf_name, is_aggregated, binding_source, perturbation_data, pseudocount))" + ] + }, + { + "cell_type": "markdown", + "id": "e6fd8197-f356-4130-9af3-03da10adf1cc", + "metadata": {}, + "source": [ + "#### Application" + ] + }, + { + "cell_type": "markdown", + "id": "7bff40a1-9220-45a6-b844-dbcc3c28a726", + "metadata": {}, + "source": [ + "Here is an applied example of using the methods above to obtain the combined data for the transcription factor AFT1 from the Calling Cards binding data and the hu_reimann perturbation data." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6c725f10-9cda-44d2-932a-87d27ff94064", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
target_locus_tageffect_bindingeffect_perturbationpvalue_bindingneg_log_pvalue_bindinglog_enrichment
4773YEL065W40.6453380.3070650.000000inf1.609011
4772YEL067C31.3549750.3092240.000000inf1.496306
1033YLR136C90.1165210.3956340.000000inf1.954804
3828YCL018W167.2265330.0555960.000000inf2.223305
2657YOR203W92.9036300.1799120.000000inf1.968033
.....................
5685YGR240C0.0000000.0704980.9922070.003398-inf
2542YOR092W0.0000000.0411090.9949330.002206-inf
941YLR044C0.0000000.0445370.9954500.001980-inf
3554YBR082C0.1308500.1852280.9954840.001966-0.883226
4441YDR233C0.0000000.1323180.9976150.001037-inf
\n", + "

6249 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " target_locus_tag effect_binding effect_perturbation pvalue_binding \\\n", + "4773 YEL065W 40.645338 0.307065 0.000000 \n", + "4772 YEL067C 31.354975 0.309224 0.000000 \n", + "1033 YLR136C 90.116521 0.395634 0.000000 \n", + "3828 YCL018W 167.226533 0.055596 0.000000 \n", + "2657 YOR203W 92.903630 0.179912 0.000000 \n", + "... ... ... ... ... \n", + "5685 YGR240C 0.000000 0.070498 0.992207 \n", + "2542 YOR092W 0.000000 0.041109 0.994933 \n", + "941 YLR044C 0.000000 0.044537 0.995450 \n", + "3554 YBR082C 0.130850 0.185228 0.995484 \n", + "4441 YDR233C 0.000000 0.132318 0.997615 \n", + "\n", + " neg_log_pvalue_binding log_enrichment \n", + "4773 inf 1.609011 \n", + "4772 inf 1.496306 \n", + "1033 inf 1.954804 \n", + "3828 inf 2.223305 \n", + "2657 inf 1.968033 \n", + "... ... ... \n", + "5685 0.003398 -inf \n", + "2542 0.002206 -inf \n", + "941 0.001980 -inf \n", + "3554 0.001966 -0.883226 \n", + "4441 0.001037 -inf \n", + "\n", + "[6249 rows x 6 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "process_transcription_factor(\"AFT1\", False, \"cc\", \"hu_reimann\")" + ] + }, + { + "cell_type": "markdown", + "id": "2a6430e2-10eb-4d46-9c52-bb977f028970", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## **Applying Transformations to the Data**" + ] + }, + { + "cell_type": "markdown", + "id": "08cb4d5c-4cca-46de-91ef-5f73a3f9920e", + "metadata": {}, + "source": [ + "Since various TFs will have different distributions of enrichment scores and poisson pvalues, it is helpful to use a ranking of these values as opposed to the magnitudes themselves to make for easier comparisons across multiple TFs. Since there are thousands of data points in each TF, using a log will shrink the scale of these ranks, allowing us to focus better on the trends in the data. We are specifically interested in how the poisson pvalue associated with TF binding relates to the actual perturbation effect. " + ] + }, + { + "cell_type": "markdown", + "id": "136aeb31-b602-4f70-8f0c-29e6c53ed0d0", + "metadata": {}, + "source": [ + "#### Code\n", + "\n", + "Thus, we take the negative log ranks of these two columns to determine if there is a relationship across all TFs. Taking the negative log of the rank means that the highest ranked data will be the least negative. Since we assign higher ranks to smaller poisson pvalues and larger perturbation effects, we would hope to see a positive linear trend when graphing this data as more significant binding interactions should ideally correlate with larger perturbations. The process_dataframe method below does this to enable more meaningful analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "bab75d9d-4466-4593-8b4c-609573ec89a5", + "metadata": {}, + "outputs": [], + "source": [ + "def process_dataframe(df: pd.DataFrame) -> pd.DataFrame:\n", + " \"\"\"\n", + " Processes a DataFrame further by calculating ranks and log transformations for expression and binding data to elucidate certain trends.\n", + " \n", + " :param df: The input DataFrame containing 'effect_perturbation' and 'pvalue_binding' columns.\n", + " :type df: pd.DataFrame\n", + " \n", + " :returns: A DataFrame that includes the original data along with new columns for expression ranks, log-transformed ranks, \n", + " binding ranks, and is sorted by the negative log-transformed binding rank.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " # Calculate expression rank with average ties method\n", + " df['expression_rank'] = rankdata(-abs(df['effect_perturbation']), method='average')\n", + "\n", + " # Log transform the expression rank\n", + " df['neg_expression_rank_log'] = -np.log10(df['expression_rank'])\n", + "\n", + " # Calculate binding rank with average ties method\n", + " df['binding_rank'] = rankdata(df['pvalue_binding'], method='average')\n", + "\n", + " # Calculate log transform of the binding rank\n", + " df['neg_log_rank_binding'] = -np.log10(df['binding_rank'])\n", + "\n", + " # Select specific columns\n", + " plotting_df = df[['target_locus_tag','effect_perturbation', 'expression_rank', 'neg_expression_rank_log', \n", + " 'pvalue_binding', 'binding_rank', 'neg_log_rank_binding']]\n", + "\n", + " # Arrange (sort) by neg_log_rank_binding in descending order\n", + " plotting_df = plotting_df.sort_values(by='neg_log_rank_binding', ascending=False)\n", + " \n", + " return plotting_df" + ] + }, + { + "cell_type": "markdown", + "id": "03e7bdcd-9dce-4e89-91b1-65aca69b8a01", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## **Visualizing the Transformed Data Using Bins**" + ] + }, + { + "cell_type": "markdown", + "id": "abcfa321-9b62-4dc0-a27e-5def161f4a7e", + "metadata": {}, + "source": [ + "The create_bins method is designed to create \"bins\" of data for a specified column in the input DataFrame. Binning data is a method of grouping continuous values into discrete intervals or \"bins.\" This process can help in reducing variance and revealing general trends in a dataset, which is needed in this instance to better see the trend between the log rank binding (LRB) and log rank perturbation response (LRR) across various TFs." + ] + }, + { + "cell_type": "markdown", + "id": "f66590a0-8faa-4521-9e78-a9f467e0a04e", + "metadata": {}, + "source": [ + "#### Code" + ] + }, + { + "cell_type": "markdown", + "id": "41dc4d1e-59f0-41f4-8aec-2ee2ac68610a", + "metadata": {}, + "source": [ + "This method gives you the option of adjusting the size of each bin, or selecting the number of bins you want to create. For example, choosing bin_size = None and num_bins = 5 will create 5 bins of equal size based on the range of LRB values, but note that the number of data points in each bin may vary as the data is not uniformly distributed." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "dd2ab269-d00b-48cc-87f9-f2ad27504b6b", + "metadata": {}, + "outputs": [], + "source": [ + "def create_bins(data: pd.DataFrame, column: str, bin_size: Optional[float] = None, num_bins: Optional[int] = None) -> pd.Series:\n", + " \"\"\"\n", + " Creates bins for a specified column in a DataFrame.\n", + " \n", + " :param data: A DataFrame containing the data to be binned.\n", + " :type data: pd.DataFrame\n", + " :param column: The name of the column to be binned.\n", + " :type column: str\n", + " :param bin_size: The size of each bin (optional, default is None). If specified, the range of the data will be partitioned into bins of this size.\n", + " :type bin_size: Optional[float]\n", + " :param num_bins: The number of bins (optional, default is None). If specified, the range of the data will be partitioned into this number of bins.\n", + " :type num_bins: Optional[int]\n", + " \n", + " :returns: A set of bins that partitions the data along the desired column value.\n", + " :rtype: pd.Series\n", + " \"\"\"\n", + " if bin_size is not None:\n", + " bin_edges = np.arange(data[column].min(), data[column].max() + bin_size, bin_size)\n", + " elif num_bins is not None:\n", + " bin_edges = np.linspace(data[column].min(), data[column].max(), num_bins + 1)\n", + " else:\n", + " raise ValueError(\"Either bin_size or num_bins must be specified\")\n", + " return pd.cut(data[column], bins=bin_edges, include_lowest=True, right=False)" + ] + }, + { + "cell_type": "markdown", + "id": "eb3f34ab-5a5d-4196-af8f-eb76d38b9f95", + "metadata": {}, + "source": [ + "The plot_with_custom_bins method creates a scatter plot to visualize the effects of this binning process on the data." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "18e56661-b814-42c0-b2c9-22db7738c873", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_with_custom_bins(data: pd.DataFrame, bin_size: Optional[float] = None, num_bins: Optional[int] = None) -> None:\n", + " \"\"\"\n", + " Bins the 'neg_log_rank_binding' column using the specified bin size or number of bins, calculates the mean of 'neg_expression_rank_log' for each bin, and plots these means against the bin centers. It also fits a LOESS line on the binned data and displays the number of data points in each bin.\n", + " \n", + " :param data: The input DataFrame containing 'neg_log_rank_binding' and 'neg_expression_rank_log' columns.\n", + " :type data: pd.DataFrame\n", + " :param bin_size: The size of each bin (optional, default is None). If specified, the range of the data will be partitioned into bins of this size.\n", + " :type bin_size: Optional[float]\n", + " :param num_bins: The number of bins (optional, default is None). If specified, the range of the data will be partitioned into this number of bins.\n", + " :type num_bins: Optional[int]\n", + " \n", + " :returns: None\n", + " :rtype: None\n", + " \"\"\"\n", + "\n", + " # Suppress specific runtime warnings\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n", + "\n", + " # Create bins for the 'neg_log_rank_binding' column using the specified bin size or number of bins\n", + " data['bin'] = create_bins(data, 'neg_log_rank_binding', bin_size, num_bins)\n", + " \n", + " # Calculate the mean of 'neg_expression_rank_log' for each bin\n", + " binned_means = data.groupby('bin', observed=True)['neg_expression_rank_log'].mean().reset_index()\n", + " \n", + " # Calculate the center of each bin for the 'neg_log_rank_binding' column\n", + " bin_centers = data.groupby('bin', observed=True)['neg_log_rank_binding'].mean().reset_index()\n", + " \n", + " # Count the number of data points in each bin and sort the counts by bin order\n", + " bin_counts = data['bin'].value_counts().sort_index().reset_index(drop=True)\n", + "\n", + " # Plotting the data\n", + " plt.figure(figsize=(10, 6)) # Set the figure size\n", + " # Create a scatter plot of bin centers vs. binned means\n", + " plt.scatter(bin_centers['neg_log_rank_binding'], binned_means['neg_expression_rank_log'], color='blue', label='Binned Means')\n", + " \n", + " # Add the number of data points for each bin as text labels on the plot\n", + " for i in range(len(bin_centers)):\n", + " plt.text(bin_centers['neg_log_rank_binding'][i], binned_means['neg_expression_rank_log'][i] - 0.007, str(bin_counts[i]), \n", + " color='black', ha='left', va='top', fontsize=9)\n", + " \n", + " # Set the labels and title for the plot\n", + " plt.xlabel('Negative Log10 Rank Binding') # Label for the x-axis\n", + " plt.ylabel('Negative Log10 Expression Rank') # Label for the y-axis\n", + " plt.title('Negative Log Rank Binding vs Negative Log Expression Rank on Binned Data') # Title of the plot\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3d6d4e77-a6b3-4139-98e5-6e333c72fffd", + "metadata": {}, + "source": [ + "#### Application" + ] + }, + { + "cell_type": "markdown", + "id": "5a8e2bb7-d766-415c-b644-026098f7f6e4", + "metadata": {}, + "source": [ + "Now that we have covered the main methods, here is an example of them in action. In this case, we are interested in displaying the binning for the single transcription factor \"AFT1.\" We are using a pseudocount of 10.3922 to calculate the enrichment scores and p values. Then we bin the data using 5 bins and graph the scatterplot." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "77eba783-acad-421a-b93a-6519de025a9d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "combined_data = process_transcription_factor(\"AFT1\", False, \"cc\", \"mcisaac\", 10.3922)\n", + "plotting_df = process_dataframe(combined_data)\n", + "plot_with_custom_bins(plotting_df, num_bins=5)" + ] + }, + { + "cell_type": "markdown", + "id": "7d246249-077f-494a-9193-e14d72773a7b", + "metadata": {}, + "source": [ + "The x-axis of this plot is the negative log of the binding poisson pvalue ranks. Recall that ties are handled by taking an average across data points with the same value to assign ranks. Data with smaller pvalue magnitudes are presumed to be more significant, therefore they occupy the highest ranks (i.e. 1, 2, 3, etc.). When taking the negative log of these ranks, points that are closer to 0 constitute points with these higher ranks, and points are that more negative correspond to lower ranked and therefore larger pvalues for binding. \n", + "\n", + "The y-axis of this plot is the negative log of the perturbation effect ranks. A similar line of logic with regard to the rankings applies here as it does with the x-axis. However, in this instance, data with larger perturbation effects are more important, and therefore they occupy the higher ranks. Thus, data that is closer to 0 corresponds to higher perturbation effects, and those that are more negative correspond to perturbation effects that are ranked lower and tend to have smaller magnitude of effect.\n", + "\n", + "Also, it is important to notice that the number of datapoints in each of the bins here is not the same. There appear to be significantly more points that occupy the leftmost bin. This means that there are likely many ties among points that have larger binding pvalues, therefore there is a greater concentration of these points in the leftmost bin in contrast to the bins on the right. By the same virtue, there is a significantly smaller quantity of points in the rightmost bin, indicating less ties among points that have smaller binding pvalues.\n", + "\n", + "The general trend of these binned means shows a postive, upward response. This finding aligns with our hypothesis that more significant binding effects (which are measured here using the poisson pvalue of binding) should correlate with points that have more significant perturbation effects (measured here using the magnitude of the perturbation effect). However, we want the trend to be consistent across all TFs, as we seek to identify a general relationship that the eventual model can learn from in hopes of enhancing its predictive power." + ] + }, + { + "cell_type": "markdown", + "id": "7e63c53a-0a6c-42ea-a1aa-62626cd5a04a", + "metadata": {}, + "source": [ + "#### Code" + ] + }, + { + "cell_type": "markdown", + "id": "f2a0d21a-9a35-4bc6-9b18-c4d8cd456512", + "metadata": {}, + "source": [ + "The process_and_plot_tfs method processes and plots data for a list of transcription factors (TFs). For each TF, it retrieves and processes the data, and then creates a plot using custom bins. This method serves as a comprehensive pipeline to handle multiple TFs, from data retrieval and processing to visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "d43424a3-707f-45dc-8fda-d705cd1a9daa", + "metadata": {}, + "outputs": [], + "source": [ + "def process_and_plot_tfs(tf_list: List[str], boolean_list: List[bool], binding_source: str, perturbation_source: str, bins: Optional[int] = 5, pseudocount: Optional[int] = 1) -> None:\n", + " \"\"\"\n", + " Processes and plots data for a list of transcription factors (TFs). This function iterates over each TF in the list, accounting for \n", + " whether or not they possess aggregate data, then processes this data and generates plots with the specified number of bins for each.\n", + " \n", + " :param tf_list: A list of transcription factor names.\n", + " :type tf_list: List[str]\n", + " :param boolean_list: A list of boolean values indicating whether the data is aggregated for each transcription factor.\n", + " :type boolean_list: List[bool]\n", + " :param perturbation_source: The source of the perturbation data.\n", + " :type perturbation_source: str\n", + " :param bins: The number of bins for plotting (optional, default is 5).\n", + " :type bins: Optional[int]\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: Optional[int]\n", + " \n", + " :returns: None\n", + " :rtype: None\n", + " \"\"\"\n", + " # Suppress RuntimeWarnings for the duration of the following operations\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n", + " \n", + " # Iterate over each transcription factor in the list\n", + " for i in range(len(tf_list)):\n", + " print(f\"Processing and plotting for TF: {tf_list[i]}\")\n", + " \n", + " # Access the transcription factor data\n", + " combined_data = process_transcription_factor(tf_list[i], boolean_list[i], binding_source, perturbation_source, pseudocount)\n", + " \n", + " # Process the combined data to calculate ranks and transformations\n", + " plotting_df = process_dataframe(combined_data)\n", + " \n", + " # Plot the processed data with custom bins\n", + " plot_with_custom_bins(plotting_df, num_bins=bins)" + ] + }, + { + "cell_type": "markdown", + "id": "d21e257e-d612-48df-9367-6f99e600a6df", + "metadata": {}, + "source": [ + "#### Application" + ] + }, + { + "cell_type": "markdown", + "id": "4105cc47-83ac-451a-807c-97504622b913", + "metadata": {}, + "source": [ + "Below is an example of a list of 4 more TFs we want to visualize this trend for, which we can do by utilizing this method" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8e1339f5-e4c4-467d-9c06-a3b8023e156f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing and plotting for TF: MIG2\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing and plotting for TF: CAT8\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing and plotting for TF: PDR1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing and plotting for TF: PHO4\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tfs = ['MIG2', 'CAT8', 'PDR1', 'PHO4']\n", + "boolean_list = [True] * 4\n", + "process_and_plot_tfs(tfs, boolean_list, \"cc\", \"mcisaac\")" + ] + }, + { + "cell_type": "markdown", + "id": "97734c61-e096-430a-9377-095b9d871eff", + "metadata": {}, + "source": [ + "While the latter 3 plots tend to exhibit the same upward trend as the plot above, the first plot for the TF MIG2 looks more unusual. The second point from the right on this plot representing the binned mean data for that range of negative log rank binding pvalues has a mean negative log expression rank that is significantly lower than expected. This means that for the data points within that bin, which is second only to the bin containing the points with the smallest binding pvalues, has on average the lowest ranked perturbation effects out of all of the bins. However, it is also important here to recognize the scale of the y-axis. Neither the positive nor negative trends we have observed exhibit a large change. Even through the graphs can look quite significant, it is important to recognize that the scale of the y-axis is actually quite small." + ] + }, + { + "cell_type": "markdown", + "id": "e870e774-cf5c-4273-b2ad-66cdcf5a573d", + "metadata": {}, + "source": [ + "For further exploration of this trend across more TFs, below is example of code that will plot the trend for 71 TFs including the 5 shown above. You can continue exploring how this trend persists across TFs." + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "b543fed4-999b-491e-ab61-d43e454d63d9", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "#tfs = ['WTM1', 'MIG2', 'CAT8', 'PDR1', 'PHO4', 'RIM101', 'GZF3', 'VHR1', 'ASH1', 'GAT3','FHL1', 'TEC1', 'SIP3', 'SKN7', 'WTM2','PHO2', 'HAA1', 'ADR1', 'MET31', 'CRZ1', 'RPH1', 'CHA4', 'CAD1', 'ZAP1', 'SKO1', 'ACA1', 'FZF1', 'HAP2', 'HAP3', 'HAP5','INO4', 'ERT1', 'TOG1', 'MET4', 'PPR1', 'RTG1', 'GLN3', 'MOT3', 'AFT1', 'GIS1', 'CBF1', 'SUM1', 'MSN2', 'DAL80', 'UPC2','RTG3', 'GAL80', 'RSF2', 'RME1', 'HIR2', 'SIP4', 'GCR1', 'HAP4', 'UME1', 'MET32', 'USV1', 'MGA1', 'CIN5', 'ROX1','XBP1', 'ZNF1', 'YHP1', 'RDR1', 'PDR3', 'RLM1', 'SFL1', 'SMP1', 'SUT2', 'HAC1', 'PHD1', 'ARO80']\n", + "#len(tfs)\n", + "#boolean_list = [True] * 59 + [False] * 12\n", + "#process_and_plot_tfs(tfs, boolean_list, \"cc\", \"mcisaac\")" + ] + }, + { + "cell_type": "markdown", + "id": "9b993bbb-091d-4d13-a22f-0419e99cdad8", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## **Further Visualization Techniques on the Data**" + ] + }, + { + "cell_type": "markdown", + "id": "03072ff9-a7de-48b8-90d6-c25f87fc4372", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### **Boxplots of Adjacent Binned Mean Differences**" + ] + }, + { + "cell_type": "markdown", + "id": "de1d438a-27dd-4e1c-9dd9-1f8ddb29ddb5", + "metadata": {}, + "source": [ + "As we have seen above, even after transforming the data and applying this method of binning, the general trend that we expect to see isn't present in every transcription factor. While looking at the graph of each TF can be helpful, it would be important to investigate how this trend holds up in general across all of the TFs in our database, especially as that number becomes quite large and manual inspection of each TF is not optimal." + ] + }, + { + "cell_type": "markdown", + "id": "779cbd7d-8b1f-4d33-8978-38a79e6ed277", + "metadata": {}, + "source": [ + "#### Code" + ] + }, + { + "cell_type": "markdown", + "id": "40cd6ca9-a460-403a-982e-61f8a12bdbad", + "metadata": {}, + "source": [ + "The following method adjacent_differences_box_plot will create four boxplots on the same plot based on the binning process used above. For our exploratory data analysis, we settled on using 5 bins as the initial graphs for all TFs exhibited the best trends when usin this number of bins. Thus, for each TF, the method will calculate the difference between two adjacent bin means, doing this four times total for the five binned means. For each of the four values, the data across all TFs is aggregated, and a boxplot is made for each of these four datasets to visualize the trend in across all TFs." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4b45b7d8-3298-4ab4-ac84-22b89e743048", + "metadata": {}, + "outputs": [], + "source": [ + "def adjacent_differences_store_data(tfs: List[str], boolean_list: List[bool], binding_source: List[str], perturbation_sources: List[str], bins: int, pseudocount: Optional[int] = 1) -> dict:\n", + " \"\"\"\n", + " Stores the differences between adjacent bins for a list of transcription factors.\n", + " \n", + " This function processes transcription factor data, calculates differences between the means of adjacent bins,\n", + " and stores these differences across multiple transcription factors.\n", + " \n", + " :param tfs: A list of transcription factors that you want to plot.\n", + " :type tfs: List[str]\n", + " :param boolean_list: A list of boolean values indicating whether the data is aggregated for each transcription factor.\n", + " :type boolean_list: List[bool]\n", + " :param perturbation_sources: A list of sources of the perturbation data.\n", + " :type perturbation_sources: List[str]\n", + " :param bins: The number of bins to create.\n", + " :type bins: int\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: Optional[int]\n", + " \n", + " :returns: A dictionary containing the stored data for each perturbation source.\n", + " :rtype: dict\n", + " \"\"\"\n", + " # Initialize a dictionary to store differences between adjacent bins for each perturbation source\n", + " diff_data = {source: [[] for _ in range(bins - 1)] for source in perturbation_sources}\n", + "\n", + " # Suppress RuntimeWarnings for the duration of the following operations\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n", + "\n", + " # Iterate over each transcription factor in the list\n", + " for i in range(len(tfs)):\n", + " for source in perturbation_sources:\n", + " # Process the transcription factor data\n", + " combined_data = process_transcription_factor(str(tfs[i]), boolean_list[i], binding_source[i], source, pseudocount)\n", + " \n", + " # Further process the combined data to calculate ranks and transformations\n", + " plotting_df = process_dataframe(combined_data)\n", + " \n", + " # Create bins for the 'neg_log_rank_binding' column using the specified number of bins\n", + " plotting_df['bin'] = create_bins(plotting_df, 'neg_log_rank_binding', num_bins=bins)\n", + " \n", + " # Calculate the mean of 'neg_expression_rank_log' for each bin\n", + " binned_means = plotting_df.groupby('bin', observed=True)['neg_expression_rank_log'].mean().reset_index()\n", + " \n", + " # Initialize a list to store the differences between adjacent bins\n", + " binned_mean_diffs = []\n", + " \n", + " # Calculate the differences between the means of adjacent bins\n", + " for j in range(bins - 1):\n", + " binned_mean_diffs.append(binned_means[\"neg_expression_rank_log\"][j+1] - binned_means[\"neg_expression_rank_log\"][j])\n", + " \n", + " # Append the differences to the corresponding list in diff_data\n", + " for j in range(bins - 1):\n", + " diff_data[source][j].append(binned_mean_diffs[j])\n", + "\n", + " # Remove NaN values from all bin difference lists\n", + " for source in diff_data:\n", + " diff_data[source] = [[x for x in bin_diff if not pd.isnull(x)] for bin_diff in diff_data[source]]\n", + "\n", + " return diff_data" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "88161fcb-f195-4c49-ab3c-3aca412032e8", + "metadata": {}, + "outputs": [], + "source": [ + "def compare_adjacent_stored_data_box_plots(stored_data_list: List[dict], labels: List[str]) -> None:\n", + " \"\"\"\n", + " Generates a box plot comparing multiple sets of stored data and adds a horizontal line at y=0.\n", + " \n", + " :param stored_data_list: A list of dictionaries containing stored data for each perturbation source.\n", + " :type stored_data_list: List[dict]\n", + " :param labels: A list of labels corresponding to each set of stored data.\n", + " :type labels: List[str]\n", + " \n", + " :returns: None\n", + " :rtype: None\n", + " \"\"\"\n", + " plt.figure(figsize=(20, 13))\n", + " boxplot_data = []\n", + " source_labels = []\n", + " bin_labels = []\n", + "\n", + " for j in range(4):\n", + " for idx, stored_data in enumerate(stored_data_list):\n", + " for source, data in stored_data.items():\n", + " boxplot_data.append(data[j])\n", + " source_labels.append(labels[idx])\n", + " bin_labels.append(f'Bins {j+1} and {j+2}')\n", + "\n", + " box_positions = list(range(1, len(boxplot_data) + 1))\n", + "\n", + " plt.boxplot(boxplot_data, positions=box_positions, widths=0.6)\n", + " plt.axhline(y=0, color='gray', linestyle='--') \n", + "\n", + " # Set the primary x-axis labels (perturbation sources)\n", + " plt.xticks(ticks=box_positions, labels=source_labels, rotation=90, ha='center')\n", + "\n", + " # Add bin labels below the primary x-axis\n", + " ax = plt.gca()\n", + " ax2 = ax.secondary_xaxis('bottom')\n", + " unique_bins = list(set(bin_labels))\n", + " bin_label_positions = []\n", + " for unique_bin in unique_bins:\n", + " positions = [box_positions[i] for i, bin_label in enumerate(bin_labels) if bin_label == unique_bin]\n", + " center_position = sum(positions) / len(positions)\n", + " bin_label_positions.append(center_position)\n", + " ax2.set_xticks(bin_label_positions)\n", + " ax2.set_xticklabels(unique_bins, rotation=0, ha='center', weight='bold', fontsize=12)\n", + " \n", + " # Adjust the position of the primary x-axis labels and the secondary x-axis labels\n", + " plt.subplots_adjust(bottom=0.3) # Adjust bottom to make space for source labels\n", + " ax.tick_params(axis='x', which='major', pad=25) # Increase the padding for the source labels\n", + "\n", + " plt.xlabel('Perturbation Sources and Bins') \n", + " plt.ylabel('Difference in Binned LRR Means') \n", + " plt.title('Comparison of Adjacent Binned LRR Mean Differences Between Perturbation Sources')\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f34afe91-ba83-4cf9-a997-67a422cdf72a", + "metadata": {}, + "source": [ + "#### Application" + ] + }, + { + "cell_type": "markdown", + "id": "4f5cc6b3-9a9e-45ea-b309-91c8cf0de6b0", + "metadata": {}, + "source": [ + "Here, we use this method to plot the boxplots for the above TF data. Note that we are augmenting the Calling Cards binding data with data from the mitra lab. You can see the breakdown of which TFs come from which set by referencing the index of the all_tfs list with the cc_to_mitra_ratio_in_all list." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a6e69fa0-bdc4-4cdd-9a57-25c7d08f8330", + "metadata": {}, + "outputs": [], + "source": [ + "all_tfs = ['WTM1','MIG2','RIM101','GZF3','ASH1','GAT3','TEC1','SIP3','SKN7','WTM2','HAA1','MET31','CRZ1','CHA4','ZAP1','SKO1','ACA1','FZF1','HAP2','HAP3','HAP5','INO4','ERT1','PPR1','RTG1','MOT3','CBF1','MSN2','DAL80','RTG3','GAL80','RSF2','RME1','HIR2','SIP4','HAP4','UME1','USV1','MGA1','CIN5','ROX1','XBP1','RDR1','PDR3','RLM1','SFL1','SMP1','SUT2','PHD1','SUT1','SOK2','STP2','YRR1','GAL4','LEU3','OAF1','SWI6','ACE2','TYE7','RGM1','GCN4','MIG3','STB5','RFX1','ARG80','ARG81','CST6','AZF1','SFP1','GTS1','FKH1','YOX1','FKH2','DIG1','MET28','RGT1','GCR2']\n", + "boolean_list = [True]*41 + [False]*37\n", + "cc_to_mitra_ratio_in_all = [\"cc\"]*49+[\"mitra\"]*29" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "573634e7-80cf-4e30-85db-ff90d244ce04", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "cc_mcisaac_adjacent_boxplot_data = adjacent_differences_store_data(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, [\"mcisaac\"]*78, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "d192b86e-4e49-48b8-9b5c-5afcd4335461", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "compare_adjacent_stored_data_box_plots([cc_mcisaac_adjacent_boxplot_data], [\"cc/mcisaac\"])" + ] + }, + { + "cell_type": "markdown", + "id": "e4ebb0b2-aa74-4548-bbed-747065401893", + "metadata": {}, + "source": [ + "This boxplot illustrates the differences in the binned mean LRR values (as shown on the y-axis) between adjacent bins (on the x-axis) across 71 transcription factors. For instance, \"Bins 1 and 2\" shows the difference in expression ranks between the first and second bins, \"Bins 2 and 3\" between the second and third bins, and so on. In the first boxplot, representing \"Bins 1 and 2,\" the interquartile range (IQR) is very narrow, and the median difference is around zero, indicating little change in expression ranks between these bins for most TFs. \n", + "\n", + "As we move to \"Bins 2 and 3,\" a similar trend is observed, with the median still close to zero and a narrow spread of the data near 0, suggesting minimal differences in expression ranks between these bins. However, as we progress to \"Bins 3 and 4\" and \"Bins 4 and 5,\" we see an increasing spread in the data. The median differences for these bins are also higher, especially in \"Bins 4 and 5,\" where the median is significantly above zero. This indicates that for many TFs, there is a noticeable change in expression ranks in the later bins, with the differences becoming more pronounced. The highest quartile in \"Bins 4 and 5\" indicates that the binned mean LRR changes considerably for some TFs, with the top of the boxplot extending to around 0.8, corresponding to a factor of 10^0.8 or approximately 6.3. This means that the expression rank could change by this factor from one bin to the next, demonstrating a significant shift. The presence of outliers further indicates that there are some TFs with even more substantial changes between these bins. \n", + "\n", + "Overall, this boxplot reveals that the differences between adjacent bins become more pronounced as we move to higher bins. This trend signifies that the expression ranks of TFs change more significantly in the later bins, highlighting a general pattern of increasing variability in the data as we move from earlier to later bins. So, while for some individual TFs the trend may not be evident (like the example shown above) it seems that across the entire dataset, this trend is generally consistent and can serve as a decent relationship that our models can use to learn from the data and result in more accurate predictions." + ] + }, + { + "cell_type": "markdown", + "id": "d5bfa2a3-d690-41b1-b686-dfb9e9da9a46", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### **Boxplots of Binned Mean Differences Between the First and Last Bins**" + ] + }, + { + "cell_type": "markdown", + "id": "46b45792-ec15-44f9-b766-4041efead340", + "metadata": {}, + "source": [ + "For a broader look at how the binned means differ, this is an additional method that takes the difference in the binned mean values between the first and last bin for each TF only. Then the data across all TFs is aggregated, and a boxplot is made to visualize the overall difference across all TFs. We can use this to determine further if there truly is a significant increase in the binned means across the first and last bins. Additionally, these boxplots are much simpler to look at for a given binding/perturbation data set compared to the 4 boxplots shown on the adjacent bin differences plot above. Thus, we can compare how these single boxplots differ across all binding and perturbation datasets by plotting them in an array that makes it easy to visualize comparisons." + ] + }, + { + "cell_type": "markdown", + "id": "959de37b-0030-4ca9-8255-6e1576fc85a5", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "#### Code" + ] + }, + { + "cell_type": "markdown", + "id": "2577e01d-7ee7-4178-9092-b5c7d6e8c82a", + "metadata": {}, + "source": [ + "The following method first_last_bin_difference_box_plot_comparisons will save the data needed to create boxplots of the first and last bin mean differences, which can then be plotted on the same plot to enable comparison between binding/perturbation dataset combinations. For each TF, the method will calculate the difference between the first and last bin means. For each of the four values, the data across all TFs is aggregated." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "1f05858b-0b67-4764-90ba-f7974555110c", + "metadata": {}, + "outputs": [], + "source": [ + "def first_last_bin_difference_box_plot_comparisons(tfs: List[str], boolean_list: List[bool], binding_source: List[str], perturbation_sources: List[str], bins: int, pseudocount: Optional[int] = 1) -> dict:\n", + " \"\"\"\n", + " Generates a box plot of the differences between the first and last bins for a list of transcription factors.\n", + " \n", + " This function processes transcription factor data, calculates differences between the means of the first and last bins,\n", + " and generates a box plot to visualize these differences across multiple transcription factors.\n", + " \n", + " :param tfs: A list of transcription factors that you want to plot.\n", + " :type tfs: List[str]\n", + " :param boolean_list: A list of boolean values indicating whether the data is aggregated for each transcription factor.\n", + " :type boolean_list: List[bool]\n", + " :param perturbation_sources: A list of sources of the perturbation data.\n", + " :type perturbation_sources: List[str]\n", + " :param bins: The number of bins to create.\n", + " :type bins: int\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: Optional[int]\n", + " \n", + " :returns: A dictionary containing the stored data for each perturbation source.\n", + " :rtype: dict\n", + " \"\"\"\n", + " # Initialize a dictionary to store differences between the first and last bins for each perturbation source\n", + " diff_data = {source: [] for source in perturbation_sources}\n", + "\n", + " # Suppress RuntimeWarnings for the duration of the following operations\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n", + "\n", + " # Iterate over each transcription factor in the list\n", + " for i in range(len(tfs)):\n", + " for source in perturbation_sources:\n", + " #print(str(i+1) +\": \"+tfs[i])\n", + " # Process the transcription factor data\n", + " combined_data = process_transcription_factor(str(tfs[i]), boolean_list[i], binding_source[i], source, pseudocount)\n", + " \n", + " # Further process the combined data to calculate ranks and transformations\n", + " plotting_df = process_dataframe(combined_data)\n", + " \n", + " # Create bins for the 'neg_log_rank_binding' column using the specified number of bins\n", + " plotting_df['bin'] = create_bins(plotting_df, 'neg_log_rank_binding', num_bins = bins)\n", + " \n", + " # Calculate the mean of 'neg_expression_rank_log' for each bin\n", + " binned_means = plotting_df.groupby('bin', observed=True)['neg_expression_rank_log'].mean().reset_index()\n", + " \n", + " # Calculate the difference between the first and last bin means\n", + " first_last_diff = binned_means[\"neg_expression_rank_log\"].iloc[-1] - binned_means[\"neg_expression_rank_log\"].iloc[0]\n", + " \n", + " # Append the difference to the corresponding list in diff_data\n", + " diff_data[source].append(first_last_diff)\n", + "\n", + " # Remove NaN values from all bin difference lists\n", + " for source in diff_data:\n", + " diff_data[source] = [x for x in diff_data[source] if not pd.isnull(x)]\n", + "\n", + " return diff_data" + ] + }, + { + "cell_type": "markdown", + "id": "93e20a2d-419a-40d6-859a-439784106276", + "metadata": {}, + "source": [ + "The compare_first_and_last_stored_data_box_plots method below plots all of the boxplots on the same plot to enable easy comparison. It takes in data generated by the method directly above and uses the data to plot all of the boxplots. Note that you need to supply labels and make sure they correspond to the correct dataset. " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "b7aefbdf-d5ce-4f2c-95af-a27bde993900", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_boxplots(data: List[List[float]], binding_labels: List[str], perturbation_labels: List[str], data_type: str) -> None:\n", + " \"\"\"\n", + " Plots an array of boxplots with specified binding and perturbation labels.\n", + "\n", + " :param data: A list of lists containing numerical data for each boxplot.\n", + " :type data: List[List[float]]\n", + " :param binding_labels: A list containing the labels for the binding data (\"cc\" and \"harbison\").\n", + " :type binding_labels: List[str]\n", + " :param perturbation_labels: A list containing the labels for the perturbation data (\"mcisaac\", \"kemmeren\", \"hu_reimann\").\n", + " :type perturbation_labels: List[str]\n", + "\n", + " :returns: None\n", + " :rtype: None\n", + " \"\"\"\n", + " # Flatten the data to find the global min and max\n", + " all_data = np.concatenate(data)\n", + " \n", + " # Calculate global min and max, rounding to the nearest 0.5\n", + " global_min = np.floor(np.min(all_data) * 2) / 2 # Round down to nearest 0.5\n", + " global_max = np.ceil(np.max(all_data) * 2) / 2 # Round up to nearest 0.5\n", + "\n", + " # Determine number of rows and columns\n", + " num_datasets = len(data)\n", + " if num_datasets == 1:\n", + " nrows, ncols = 1, 1\n", + " else:\n", + " ncols = 3\n", + " nrows = (num_datasets + ncols - 1) // ncols # Calculate the required number of rows\n", + "\n", + " # Create subplots\n", + " fig, axs = plt.subplots(nrows, ncols, figsize=(5 * ncols, 5 * nrows))\n", + " axs = np.array(axs).reshape(-1) # Flatten the 2D array of axes to iterate over them easily\n", + "\n", + " for i, ax in enumerate(axs):\n", + " if i < num_datasets:\n", + " ax.boxplot(data[i])\n", + " row = i // ncols\n", + " col = i % ncols\n", + " if col == 0 and len(binding_labels) > row:\n", + " ax.set_ylabel(binding_labels[row])\n", + " if row == nrows - 1 and len(perturbation_labels) > col:\n", + " ax.set_xlabel(perturbation_labels[col])\n", + " ax.axhline(y=0, color='red', linestyle='--') # Add dashed line at y=0\n", + " \n", + " # Set y-axis limits based on global min and max\n", + " ax.set_ylim(global_min, global_max)\n", + " else:\n", + " ax.axis('off') # Turn off any unused subplot axes\n", + " if data_type == \"diffs\":\n", + " fig.suptitle(f'Boxplot of Differences in Means Between First and Last Bins Across {len(data[0])} TFs') \n", + " elif data_type == \"correlations\":\n", + " fig.suptitle(f'Boxplot of Pearson Correlations Between LRR/LRB Across {len(data[0])} TFs') \n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "fdd45f46-117d-41be-b145-1c5c39da71f0", + "metadata": {}, + "source": [ + "#### Application" + ] + }, + { + "cell_type": "markdown", + "id": "203714b1-4ef0-4147-ada3-3ea79d4dfa4b", + "metadata": {}, + "source": [ + "We will first plot the boxplot for a single dataset that uses the CC+mitra binding data as well as the mcisaac perturbation data." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "67f4dbb2-7cf9-4db2-8ab0-c76a4af2ee54", + "metadata": {}, + "outputs": [], + "source": [ + "all_tfs = ['WTM1','MIG2','RIM101','GZF3','ASH1','TEC1','SIP3','SKN7','WTM2','HAA1','MET31','CRZ1','CHA4','ZAP1','SKO1','FZF1','HAP2','HAP3','HAP5','INO4','RTG1','MOT3','CBF1','MSN2','RTG3','RSF2','HIR2','SIP4','UME1','CIN5','ROX1','XBP1','RDR1','PDR3','RLM1','SFL1','SMP1','PHD1','SUT1','SOK2','STP2','AFT2','YRR1','GAL4','LEU3','SWI6','ACE2','RGM1','GCN4','MIG3','STB5','RFX1','ARG81','AZF1','SFP1','GTS1','FKH1','YOX1','FKH2','DIG1','MET28','RGT1']\n", + "boolean_list = [True]*31 + [False]*31\n", + "cc_to_mitra_ratio_in_all = [\"cc\"]*38+[\"mitra\"]*24" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "c9700f11-1903-42ab-836e-d2dc187e2778", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cc_mcisaac_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, perturbation_sources = [\"mcisaac\"], bins = 5)\n", + "data = [cc_mcisaac_first_last_data['mcisaac']]\n", + "plot_boxplots(data, [\"Difference in Binned LRR Means between First and Last Bin\"], [\"Data from 78 TFs\"])" + ] + }, + { + "cell_type": "markdown", + "id": "0caf408b-d6b0-412c-9662-dd11779342cc", + "metadata": {}, + "source": [ + "This graph has almost identical axes to the previous graph, except now the x-axis only shows a single value which is just the binned mean differences between the first and last bins. The y-axis is still the binned mean LRR difference between the first and last bin, and the data that generates the boxplot is taken from the 71 TFs used above. This boxplot further reinforces the argument that this general trend holds up across transcription factors. The bottom fence of the boxplot is slightly below zero, indicating that the minimum binned mean difference between the first and last bins can be slightly negative. The third quartile is around 0.5, which, when converted from the logarithmic scale (10^0.5), equates to approximately 3.3. This means that moving from the first bin to the last bin, the average response rank decreases by a factor of about 3.3. For example, if the average response rank in the first bin is 1,000, it decreases to around 300 in the last bin. While this shift may not seem drastic, it is significant enough to be noticeable and demonstrates a consistent trend across different TFs. This trend indicates that the response rank generally decreases as we move from the first bin to the last, highlighting a pattern of decreasing average response ranks in the dataset that contributes to the general upward trend we desire." + ] + }, + { + "cell_type": "markdown", + "id": "103c0b66-771c-4095-a106-a2915d2c59e1", + "metadata": {}, + "source": [ + "Now, let's visualize all of the boxplots creating using combinations of the binding or perturbation dataset in an array format to enable easier visual comparison of how all of the different datasets affect the outcomes of the differences in the first and last bins." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "bd5dd7e5-530a-457c-af46-c6d91636ef31", + "metadata": {}, + "outputs": [], + "source": [ + "chip_exo_kemmeren_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"kemmeren\"], bins = 5)\n", + "chip_exo_mcisaac_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"mcisaac\"], bins = 5)\n", + "chip_exo_hu_reimann_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"hu_reimann\"], bins = 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "2c77af23-db59-499c-bcd8-0275a4c08445", + "metadata": {}, + "outputs": [], + "source": [ + "new_cc_kemmeren_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, perturbation_sources = [\"kemmeren\"], bins = 5)\n", + "new_cc_mcisaac_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, perturbation_sources = [\"mcisaac\"], bins = 5)\n", + "new_cc_hu_reimann_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, perturbation_sources = [\"hu_reimann\"], bins = 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "18e581d0-7c82-4925-a502-1ba697acc8a9", + "metadata": {}, + "outputs": [], + "source": [ + "new_harbison_kemmeren_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, [\"harbison\"]*100, perturbation_sources = [\"kemmeren\"], bins = 5)\n", + "new_harbison_mcisaac_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, [\"harbison\"]*100, perturbation_sources = [\"mcisaac\"], bins = 5)\n", + "new_harbison_hu_reimann_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, [\"harbison\"]*100, perturbation_sources = [\"hu_reimann\"], bins = 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "5cfef4c5-9392-4837-ad9d-c5f3a15ffe65", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = [new_cc_mcisaac_first_last_data['mcisaac'], new_cc_kemmeren_first_last_data['kemmeren'], new_cc_hu_reimann_first_last_data['hu_reimann'], new_harbison_mcisaac_first_last_data['mcisaac'], new_harbison_kemmeren_first_last_data['kemmeren'], new_harbison_hu_reimann_first_last_data['hu_reimann'], chip_exo_mcisaac_first_last_data[\"mcisaac\"], chip_exo_kemmeren_first_last_data[\"kemmeren\"], chip_exo_hu_reimann_first_last_data[\"hu_reimann\"]]\n", + "binding_labels = [\"cc+mitra\", \"harbison\", \"chip_exo\"]\n", + "perturbation_labels = [\"mcisaac\", \"kemmeren\", \"hu_reimann\"]\n", + "plot_boxplots(data, binding_labels, perturbation_labels, \"diffs\")" + ] + }, + { + "cell_type": "markdown", + "id": "72185f5f-8b72-415b-a016-b57ebb8cca87", + "metadata": {}, + "source": [ + "This 3x3 array of boxplots displays the distribution of first and last bin mean differences across a common pool of 62 TFs for the 9 combinations of binding and perturbation data. The x and y-axis labels represent the corresponding binding or perturbation dataset used, respectively. For instance, the boxplot at the top right represents the boxplot of the data of the first and last bin mean differences across 62 TFs using the Calling Cards binding data and the hu_reimann perturbation data. So, in short, you can trace the binding and perturbation data used for a particular boxplot by identifying the corresponding labels on the x and y-axis which intersect at this particular boxplot. \n", + "\n", + "Now, let us examine these plots closer. For convenience, we will look at the trends within a particular row, which means looking at how the binding datasets perform relative to one another across the 3 perturbation datasets. Starting with the top row, in which all of the boxplots are created using the Calling Cards binding data, It is evident that a majority of the data in each boxplot displays a positive difference in the first and last bin means. This is important because it helps to confirm that across the various perturbation datasets used, when using the Calling Cards binding data, a generally positive difference is observed across the first and last bin means. \n", + "\n", + "Looking at the second row, which represents using the Harbison data, overall it seems to hold up the same trend. However, for the boxplot which uses the mcisaac perturbation data, it is interesting to note that around half of the data does not depict a positive trend. Additionally, for the other two boxplots in this row, which less of the data is positive, there is a greater spread of positive data than there was in the previous row using the Calling Cards data. \n", + "\n", + "Lastly, in the bottom row, which uses the chip_exo binding data, it is clear that using this binding data set produces the least desirable trends. In the boxplot which uses the mcisaac dataset, it appears that nearly half of the data is non-positive similar to the boxplot directly above it. Additionally, for the other two boxplots within this row, while more than half of the data shows a positive difference, it seems to be barely more than half, and in general seems to depict a weaker positive bin mean difference in comparison to the other two rows above it.\n", + "\n", + "Overall, however, these boxplots help to show that the various combinations of binding and perturbation datasets do show a positive bin mean difference, which is desirable. Of them, the Calling Cards binding dataset and the harbison binding dataset produce more positive distributions of the first and last bin mean difference data compared to the chip_exo binding dataset." + ] + }, + { + "cell_type": "markdown", + "id": "cd0c5c95-eebe-4678-acef-20df5683ba08", + "metadata": {}, + "source": [ + "Therefore, might also be interested in seeing how the chip_exo binding data in particular can be augmented to give a potentially more accurate look at its binding data in combination with the perturbation datasets. This is because with the chip_exo binding data in particular, when accessing the data, it only returns genes that were responsive to the transcription factor binding. This essentially means that in comparison to the Calling Cards or harbison data, which may have ~6000 rows of data when initially accessed, the chip_exo data often has less than 100 rows of data. To make the chip_exo data more reflective of both responsive and non-responsive transcription factor binding events, we can add additional rows of data for each gene not included in the original chip_exo dataset for a particular TF based on genes that exist in the perturbation dataset chosen, setting the enrichment score to be 0, and the p-value of binding to be the smallest insignificant p-value. Our modification to the process_transcription_factor_async method below achieves this goal. We can then graph the boxplots again to evaluate how these boxplots incorporating the new chip_exo augmented dataset are different from the ones above." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "81efc54a-6324-43bb-9aad-8e89c1a3081d", + "metadata": {}, + "outputs": [], + "source": [ + "async def process_transcription_factor_async(tf_name: str, is_aggregated: bool, binding_source: str, perturbation_source: str, pseudocount: int = 1) -> pd.DataFrame: \n", + " \"\"\"\n", + " Process transcription factor data by retrieving and merging binding and perturbation datasets.\n", + "\n", + " :param tf_name: The name of the transcription factor, e.g., \"AR080\".\n", + " :type tf_name: str\n", + " :param is_aggregated: Indicates whether the data is aggregated.\n", + " :type is_aggregated: bool\n", + " :param binding_source: The source of the binding data, e.g., \"cc\" or \"harbison\".\n", + " :type binding_source: str\n", + " :param perturbation_source: The source of the perturbation data, e.g., \"mcisaac\".\n", + " :type perturbation_source: str\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: int, optional\n", + "\n", + " :returns: A DataFrame containing the combined and processed binding and perturbation data.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " # Ensure the TF name is in uppercase to maintain consistency\n", + " tf_name_upper = tf_name.upper()\n", + " \n", + " # Initialize API for binding data\n", + " pss_api_tf = PromoterSetSigAPI()\n", + "\n", + " # Access the relevant data depending on the binding source and aggregation status\n", + " if binding_source == \"cc\":\n", + " if is_aggregated:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"datasource\": \"brent_nf_cc\", \"aggregated\": \"true\"})\n", + " else:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"workflow\": \"nf_core_callingcards_1_0_0\", \"data_usable\": \"pass\"})\n", + " elif binding_source == \"harbison\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"4\"})\n", + " elif binding_source == \"mitra\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"2\"})\n", + " elif binding_source == \"chip_exo\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"3\"})\n", + "\n", + " # Asynchronously read the binding data from the API\n", + " tf_pss = await pss_api_tf.read(retrieve_files=True)\n", + " # Get the ID of the retrieved binding data\n", + " id = tf_pss.get(\"metadata\")[\"id\"][0]\n", + " # Extract the binding data using the ID\n", + " binding_df = tf_pss.get(\"data\").get(str(id))\n", + "\n", + " # Initialize API for perturbation data\n", + " expression = ExpressionAPI()\n", + "\n", + " # Map perturbation source to corresponding source number\n", + " source_mapping = {\n", + " \"mcisaac\": \"7\",\n", + " \"hu_reimann\": \"5\",\n", + " \"kemmeren\": \"6\"\n", + " }\n", + " source_number = source_mapping.get(perturbation_source, \"unknown\")\n", + " \n", + " # Push parameters to retrieve the perturbation data\n", + " if perturbation_source == \"mcisaac\":\n", + " expression.push_params({\"regulator_symbol\": tf_name_upper, \"source\": source_number, \"time\": \"15\"})\n", + " else:\n", + " expression.push_params({\"regulator_symbol\": tf_name_upper, \"source\": source_number})\n", + "\n", + " # Asynchronously read the perturbation data from the API\n", + " expression_res = await expression.read(retrieve_files=True)\n", + " # Get the ID of the retrieved perturbation data\n", + " id = expression_res.get(\"metadata\")[\"id\"][0]\n", + " # Extract the perturbation data using the ID\n", + " expression_df = expression_res.get(\"data\").get(str(id))\n", + "\n", + " # Read perturbation data\n", + " perturbation_data = expression_df\n", + " # Read binding data\n", + " binding_data = binding_df\n", + "\n", + " # Rename columns in binding data for consistency and clarity\n", + " if binding_source == \"cc\":\n", + " binding_data.rename(columns={\"callingcards_enrichment\": \"effect\", \"poisson_pval\": \"pvalue\"}, inplace=True)\n", + " elif binding_source == \"harbison\":\n", + " binding_data.rename(columns={\"pval\": \"pvalue\"}, inplace=True)\n", + " elif binding_source == \"mitra\":\n", + " binding_data.rename(columns={\"callingcards_enrichment\": \"effect\", \"poisson_pval\": \"pvalue\"}, inplace=True)\n", + " elif binding_source == \"chip_exo\":\n", + " binding_data.rename(columns={\"max_fc\": \"effect\", \"min_pval\": \"pvalue\"}, inplace=True)\n", + "\n", + " # Optional: here you can modify the pseudocount as needed. The default pseudocount is set to 1.\n", + " # Calculate the effect size for binding data using the provided formula\n", + " if binding_source == \"cc\":\n", + " binding_data['effect'] = (binding_data['experiment_hops'] / binding_data['experiment_total_hops']) / \\\n", + " ((binding_data['background_hops'] + pseudocount) / binding_data['background_total_hops'])\n", + "\n", + " missing_values = set(perturbation_data[\"target_locus_tag\"]) - set(binding_data[\"target_locus_tag\"])\n", + "\n", + " # Add missing rows to the binding data with enrichment = 0 and pvalue = 1\n", + " if missing_values:\n", + " missing_rows = pd.DataFrame({\n", + " 'target_locus_tag': list(missing_values),\n", + " 'effect': 0,\n", + " 'pvalue': -4.322 #since this is for the chipexo data, we find log2 (0.05) \n", + " })\n", + " binding_data = pd.concat([binding_data, missing_rows], ignore_index=True)\n", + "\n", + " # Merge the binding data and perturbation data on the 'target_locus_tag' column\n", + " combined_data = pd.merge(binding_data, perturbation_data, on='target_locus_tag', suffixes=('_binding', '_perturbation'))\n", + "\n", + " # # Assert that the length of combined_data is the minimum of the lengths of binding_data and perturbation_data\n", + " # assert len(combined_data) <= min(len(binding_data), len(perturbation_data)), \\\n", + " # f\"Length of combined_data ({len(combined_data)}) is not equal to the minimum of lengths of binding_data ({len(binding_data)}) and perturbation_data ({len(perturbation_data)})\"\n", + "\n", + " # Keep only the necessary columns in the combined data\n", + " combined_data = combined_data[['target_locus_tag', 'effect_binding', 'effect_perturbation', 'pvalue_binding']]\n", + "\n", + " # Reorder the combined data by the smallest 'pvalue_binding' values\n", + " combined_data = combined_data.sort_values(by='pvalue_binding')\n", + "\n", + " # Apply transformations:\n", + " # - Take the absolute value of 'effect_perturbation'\n", + " # - Calculate the negative log10 of 'pvalue_binding'\n", + " # - Calculate the log10 of 'effect_binding'\n", + " combined_data['effect_perturbation'] = combined_data['effect_perturbation'].abs()\n", + " combined_data['neg_log_pvalue_binding'] = -np.log10(combined_data['pvalue_binding'])\n", + " combined_data['log_enrichment'] = np.log10(combined_data['effect_binding'])\n", + "\n", + " # Return the processed combined data as a DataFrame\n", + " return combined_data\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fda12cd6-b4ac-4350-be99-a24ac0b2cb5a", + "metadata": {}, + "outputs": [], + "source": [ + "filled_chip_exo_kemmeren_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"kemmeren\"], bins = 5)\n", + "filled_chip_exo_mcisaac_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"mcisaac\"], bins = 5)\n", + "filled_chip_exo_hu_reimann_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"hu_reimann\"], bins = 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "27cf8f10-7f3a-4ec3-96a6-d6a41e3fc6fc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABdEAAAXDCAYAAAA/S3eaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAADny0lEQVR4nOzdeXxU9bk/8CcJEHbcWBUBRQUFRXFBMAJ14SqoSHG9VNxti7ZWrC3eVqpt4Vql2ta6tVW8KraKFCutCyoKStSK1YqCooJaCmhFAgKCJOf3B7+MjORgCCETyPv9ep2X5sz3nPOcycw8zGdOvpOXJEkSAAAAAADARvJzXQAAAAAAANRWQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdACoYXl5efGTn/wk12Vk+fvf/x69e/eOJk2aRF5eXrzyyivVtu/x48dHXl5eLFiwIGv9ddddF3vssUcUFBREjx49IiJi3bp1ccUVV0T79u0jPz8/Bg8eXG11bI8WLFgQeXl5MX78+FyXAhlPP/105OXlxdNPP53rUra6fv36Rb9+/XJdRo06++yzo2PHjrkuAwCgRgnRAdhulIe1Gy6tWrWK/v37xyOPPJLr8rbYG2+8ET/5yU82CqO31Oeffx6nnHJKLF26NG644Ya4++67o0OHDhWOLQ/HypfCwsJo3bp19OvXL8aMGRMfffRRpY75+OOPxxVXXBF9+vSJO++8M8aMGRMREXfccUdcd911MXTo0Ljrrrvie9/7XrWdJ5XTr1+/yMvLi7322qvC26dOnZr5/U+cOLGGq6teP/nJT7Iez/n5+dG2bdsYNGhQPP/881Xe75gxY2Ly5MnVV2gt8+X7bcPl1ltvrfbjrVq1Kn7yk59s06F8x44dY9CgQTV2vJtvvnmzPlz78u+xSZMmse+++8bPfvazWLVq1dYrtAquuOKKyMvLi9NOOy3XpWxVa9eujTFjxkSXLl2iYcOG0bp16xg4cGD861//yoz5+9//HhdffHHst99+0aRJk9h9993j1FNPjbfeemuT+y7/ALYyy4IFCzbq/Rsup59++ta+KwCgVqiX6wIAoLpdc8010alTp0iSJJYsWRLjx4+P448/Ph5++OEaDTGq2xtvvBFXX3119OvXr1qvAnznnXfivffei9/97ndx/vnnV2qb73znO3HIIYdEaWlpfPTRRzFz5swYPXp0/PKXv4z7778/vva1r2XGfuMb34jTTz89CgsLM+ueeuqpyM/Pjz/84Q/RoEGDrPW77rpr3HDDDdV2ftuzDh06xOrVq6N+/frVut+GDRvG22+/HS+++GIceuihWbfde++90bBhw/jss8+q9Zi5dMstt0TTpk2jrKwsPvjgg/jd734XRx55ZLz44ouZv5LYHGPGjImhQ4du939JUX6/beiwww6LPffcM1avXp313N4Sq1atiquvvjoios5d9V1VN998c+yyyy5x9tlnV3qbY445Js4666yIiPj0009jxowZ8eMf/zheffXVeOCBBzLjfve730VZWVl1l1wpSZLEfffdFx07doyHH344VqxYEc2aNctJLVvT559/HgMHDoyZM2fGBRdcEPvvv3988skn8cILL0RJSUnstttuERFx7bXXxnPPPRennHJK7L///rF48eK46aab4qCDDornn38+unXrVuH+W7ZsGXfffXfWunHjxsW//vWvjfpvy5YtMx/el/f+DfmrBADqCiE6ANud4447Lg4++ODMz+edd160bt067rvvvm06RN9aPvzww4iI2GGHHSq9TVFRUQwdOjRr3auvvhrHHntsfP3rX4833ngj2rZtGxERBQUFUVBQsNExGzVqtFHI9uGHH25WHV8lSZL47LPPolGjRtW2z9okLy8vGjZsWO373XPPPWPdunVx3333ZYXon332Wfz5z3+OgQMHxoMPPljtx82VoUOHxi677JL5efDgwdGtW7d44IEHqhSi1xVfvt82VJnH5apVq6Jx48bVXRZVtPfee8ewYcMyP3/zm9+MtWvXxqRJk+Kzzz7L/E6r+0O7zfH000/Hv/71r3jqqadiwIABMWnSpBg+fHi17HvlypXRpEmTatnXlrrhhhvimWeeiWeffXajDzI3dNlll8WECROyeulpp50W3bt3j//93/+Ne+65p8LtmjRpkvW7joj44x//GJ988slG6zdUUe8HgLrCdC4AbPd22GGHaNSoUdSrl/3Z8cqVK2PkyJHRvn37KCwsjH322Seuv/76SJIkIiJWr14dXbp0iS5dusTq1asz2y1dujTatm0bvXv3jtLS0ohYP0ds06ZN4913340BAwZEkyZNol27dnHNNddk9rcp//jHP+K4446L5s2bR9OmTeOoo47Kmk5i/Pjxccopp0RERP/+/TN/Rv1V0xs89dRTUVRUFE2aNIkddtghTjrppJgzZ07m9rPPPjv69u0bERGnnHJK5OXlVflKzwMOOCBuvPHGWLZsWdx0001ZtW84J3peXl7ceeedsXLlysx5lI+ZNm1avP766xudX1lZWdx4442x3377Zf6s/aKLLopPPvkkq4byKRMee+yxOPjgg6NRo0Zx2223RUTEsmXL4tJLL838vjt37hzXXntt1hWV5X/ifv3118ftt98ee+65ZxQWFsYhhxwSf//73zc657lz58app54aLVu2jEaNGsU+++wT//M//5M1ZuHChXHuuedG69ato7CwMPbbb7+44447NtrXb37zm9hvv/2icePGseOOO8bBBx8cEyZM2OR9XtGc6OWPxYULF8bgwYOjadOm0bJly7j88sszj9fKOOOMM+JPf/pT1v3z8MMPx6pVq+LUU0+tcJvKnOvatWvjqquuip49e0aLFi2iSZMmUVRUFNOmTavw3Crzu1i8eHGcc845sdtuu0VhYWG0bds2TjrppCpPfdSmTZuIiI1eM9asWROjR4+Ozp07R2FhYbRv3z6uuOKKWLNmTWZMXl5erFy5Mu66667M4/jss8+Of/7zn5GXlxd/+ctfMmNnzZoVeXl5cdBBB2Ud57jjjovDDjssa90jjzySeS43a9YsBg4cGK+//vpGtc+dOzeGDh0aO+20UzRs2DAOPvjgrGNGfPGcfO655+Kyyy6Lli1bRpMmTeLkk0+u9JRMm1LRnOj9+vWLbt26xaxZs+LII4+Mxo0bx5VXXhkRES+99FIMGDAgdtlll2jUqFF06tQpzj333IhY/zho2bJlRERcffXVmft0U98rsXTp0rj88suje/fu0bRp02jevHkcd9xx8eqrr1ZY5/333x8///nPY7fddouGDRvGUUcdFW+//fZG+y1/HDZq1CgOPfTQmDFjxhbeU9lmzJgRp5xySuy+++6Zx9f3vve9rP4T8dWP944dO8brr78ezzzzTOb+qurreps2bSIvLy/rufDlOdFr8rl67733xr777hv9+/ePo48+Ou69994Kxy1cuDDOO++8aNeuXRQWFkanTp3iW9/6VqxduzYivngOPPPMM/Htb387WrVqlbm6O2L9lfz77bdfFBYWRrt27WLEiBGxbNmyrGPMmzcvvv71r0ebNm2iYcOGsdtuu8Xpp58eJSUlmTFTp06NI444InbYYYdo2rRp7LPPPpnHfZqysrL41a9+FSeffHIceuihsW7dutQpdXr37r3Rh9F77bVX7Lffflm9vqZs6rkMANs6V6IDsN0pKSmJ//znP5EkSXz44Yfxm9/8Jj799NOsq6uSJIkTTzwxpk2bFuedd1706NEjHnvssfj+978fCxcujBtuuCEaNWoUd911V/Tp0yf+53/+J375y19GRMSIESOipKQkxo8fn3WFdWlpafzXf/1X9OrVK37xi1/Eo48+GqNHj45169bFNddck1rv66+/HkVFRdG8efO44ooron79+nHbbbdFv3794plnnonDDjssjjzyyPjOd74Tv/71r+PKK6+Mrl27RkRk/luRJ554Io477rjYY4894ic/+UmsXr06fvOb30SfPn3i5Zdfjo4dO8ZFF10Uu+66a4wZMybzZ9qtW7eu8n0/dOjQOO+88+Lxxx+Pn//85xWOufvuu+P222+PF198MX7/+99HRMSBBx4Yd999d/z85z+PTz/9NMaOHZt1fhdddFGMHz8+zjnnnPjOd74T8+fPj5tuuin+8Y9/xHPPPZd1ZeSbb74ZZ5xxRlx00UVxwQUXxD777BOrVq2Kvn37xsKFC+Oiiy6K3XffPWbOnBmjRo2KRYsWxY033phV44QJE2LFihVx0UUXRV5eXvziF7+IIUOGxLvvvps51j//+c8oKiqK+vXrx4UXXhgdO3aMd955Jx5++OHMuS9ZsiR69eoVeXl5cfHFF0fLli3jkUceifPOOy+WL18el156aUSsnx7hO9/5TgwdOjS++93vxmeffRb//Oc/44UXXogzzzxzs38PpaWlMWDAgDjssMPi+uuvjyeeeCLGjRsXe+65Z3zrW9+q1D7OPPPMzDzU5dPzTJgwIY466qho1arVRuMre67Lly+P3//+93HGGWfEBRdcECtWrIg//OEPMWDAgAqnT6nM7+LrX/96vP7663HJJZdEx44d48MPP4ypU6fG+++/X6mpBpYuXRoR68OrhQsXxk9/+tNo2LBh1ocFZWVlceKJJ8azzz4bF154YXTt2jVee+21uOGGG+Ktt97KzIF+9913x/nnnx+HHnpoXHjhhRGx/sr+bt26xQ477BDTp0+PE088MSLWh6b5+fnx6quvxvLly6N58+ZRVlYWM2fOzGxbvs/hw4fHgAED4tprr41Vq1bFLbfcEkcccUT84x//yJzj66+/Hn369Ildd901fvjDH0aTJk3i/vvvj8GDB8eDDz4YJ598ctZ5X3LJJbHjjjvG6NGjY8GCBXHjjTfGxRdfHH/605++8j7b8H4rV1BQEDvuuGPq+I8//jiOO+64OP3002PYsGHRunXr+PDDD+PYY4+Nli1bxg9/+MPYYYcdYsGCBTFp0qSIWD+VxC233BLf+ta34uSTT44hQ4ZERMT++++fepx33303Jk+eHKecckp06tQplixZErfddlv07ds33njjjWjXrl3W+P/93/+N/Pz8uPzyy6OkpCR+8YtfxH//93/HCy+8kBnzhz/8IS666KLo3bt3XHrppfHuu+/GiSeeGDvttFO0b9++UvfXV3nggQdi1apV8a1vfSt23nnnePHFF+M3v/lN/Otf/8qaTuWrHu833nhjXHLJJdG0adPMh3qVeV3/7LPP4j//+U9ErP+Q+bnnnou77rorzjzzzI0+UKrI1n6urlmzJh588MEYOXJkRKz/oO+cc86JxYsXZz74ioj497//HYceemgsW7YsLrzwwujSpUssXLgwJk6cGKtWrcoKnb/97W9Hy5Yt46qrroqVK1dGxPo5/6+++uo4+uij41vf+la8+eabccstt8Tf//73TL9Zu3ZtDBgwINasWROXXHJJtGnTJhYuXBhTpkyJZcuWRYsWLeL111+PQYMGxf777x/XXHNNFBYWxttvvx3PPffcJs/zjTfeiH//+9+x//77x4UXXhh33XVXrF27Nrp37x6/+tWvon///pvcvnwqu/3222+T46pixYoVmcdIuZ122iny8/O/8rkMANu8BAC2E3feeWcSERsthYWFyfjx47PGTp48OYmI5Gc/+1nW+qFDhyZ5eXnJ22+/nVk3atSoJD8/P5k+fXrywAMPJBGR3HjjjVnbDR8+PImI5JJLLsmsKysrSwYOHJg0aNAg+eijjzLrIyIZPXp05ufBgwcnDRo0SN55553Mun//+99Js2bNkiOPPDKzrvzY06ZNq9T90aNHj6RVq1bJxx9/nFn36quvJvn5+clZZ52VWTdt2rQkIpIHHnjgK/dZmbEHHHBAsuOOO2Z+Lv+9zJ8/P7Nu+PDhSZMmTTbatm/fvsl+++2XtW7GjBlJRCT33ntv1vpHH310o/UdOnRIIiJ59NFHs8b+9Kc/TZo0aZK89dZbWet/+MMfJgUFBcn777+fJEmSzJ8/P4mIZOedd06WLl2aGffQQw8lEZE8/PDDmXVHHnlk0qxZs+S9997L2mdZWVnm/88777ykbdu2yX/+85+sMaeffnrSokWLZNWqVUmSJMlJJ5200XlXRnm9d955Z2Zd+WPxmmuuyRp74IEHJj179vzKfW74Ozj44IOT8847L0mSJPnkk0+SBg0aJHfddVeFj4PKnuu6deuSNWvWZI355JNPktatWyfnnnvuRuf2Vb+LTz75JImI5LrrrvvKc/uy0aNHV/iascMOO2z0GLr77ruT/Pz8ZMaMGVnrb7311iQikueeey6zrkmTJsnw4cM3Ot7AgQOTQw89NPPzkCFDkiFDhiQFBQXJI488kiRJkrz88stJRCQPPfRQkiRJsmLFimSHHXZILrjggqx9LV68OGnRokXW+qOOOirp3r178tlnn2XWlZWVJb1790722muvzLry5+TRRx+d9Xj93ve+lxQUFCTLli2r0v3WoUOHJEm+eJ3Y8LWqb9++SUQkt956a9a+/vznPycRkfz9739PPd5HH3200evmpnz22WdJaWlp1rr58+cnhYWFWc+L8jq7du2a9Zj81a9+lURE8tprryVJkiRr165NWrVqlfTo0SNr3O23355ERNK3b9+vrKlDhw7JwIEDNzmm/DmyobFjxyZ5eXmZ15nKPt7322+/StVVrqLfZ0QkgwcPzno8Jcn615jy33WS1MxzNUmSZOLEiUlEJPPmzUuSJEmWL1+eNGzYMLnhhhuyxp111llJfn5+hY+p8sd7+XPgiCOOSNatW5e5/cMPP0waNGiQHHvssVmPoZtuuimJiOSOO+5IkiRJ/vGPf3xlL7zhhhuSiMjq/5UxadKkzP251157JXfeeWdy5513JnvttVfSoEGD5NVXX93k9nfffXcSEckf/vCHzTruwIEDs36vGyp/rlS0lPf2yjyXAWBbZjoXALY7v/3tb2Pq1KkxderUuOeee6J///5x/vnnZ10N9be//S0KCgriO9/5Tta2I0eOjCRJ4pFHHsms+8lPfhL77bdfDB8+PL797W9H3759N9qu3MUXX5z5//IrcteuXRtPPPFEheNLS0vj8ccfj8GDB8cee+yRWd+2bds488wz49lnn43ly5dv9n2waNGieOWVV+Lss8+OnXbaKbN+//33j2OOOSb+9re/bfY+K6tp06axYsWKatvfAw88EC1atIhjjjkm/vOf/2SWnj17RtOmTTeaBqRTp04xYMCAjfZRVFQUO+64Y9Y+jj766CgtLY3p06dnjT/ttNOyrqgtKiqKiPVXuEZEfPTRRzF9+vQ499xzY/fdd8/aNi8vLyLWXw344IMPxgknnBBJkmQdd8CAAVFSUhIvv/xyRKyfcuhf//pXhVPGVNU3v/nNrJ+Liooy9VfWmWeeGZMmTYq1a9fGxIkTo6CgYKOrmSM271wLCgoyV4KWlZXF0qVLY926dXHwwQdnxmzoq34X5XPrP/300xtN71NZDz74YEydOjUef/zxuPPOO2PvvfeOr3/96zFz5szMmAceeCC6du0aXbp0yTq/8qv0v/w4rEhRUVG8/PLLmSten3322Tj++OOjR48emalBZsyYEXl5eXHEEUdExPrpIJYtWxZnnHFG1nELCgrisMMOyxx36dKl8dRTT8Wpp56auVr0P//5T3z88ccxYMCAmDdvXixcuDCrngsvvDDzeC2vr7S0NN57773Nut/Kl7SpNcoVFhbGOeeck7Wu/DsQpkyZEp9//nmljvtVCgsLIz9//duc0tLS+PjjjzNTaVT0GDvnnHOyrk7+8mPspZdeig8//DC++c1vZo07++yzo0WLFtVSc0RkfXfDypUr4z//+U/07t07kiSJf/zjH5kxW/p4T3PSSSdlfpcPPfRQjBo1Kh599NE488wzKzUt2dZ+rt57771x8MEHR+fOnSMiMtMabfi4Kysri8mTJ8cJJ5yQ9d0o5TZ8vEdEXHDBBVl/UfbEE0/E2rVr49JLL808hsrHNW/ePP76179GRGR+74899ljqVCvlj+2HHnpos76I9dNPP42I9Vd9P/nkk3H22WfH2WefHU888UQkSRK/+MUvUredO3dujBgxIg4//PBqmyt+Q1dddVXWc37q1KmZvwLYGs9lAKhNTOcCwHbn0EMPzXrzfMYZZ8SBBx4YF198cQwaNCgaNGgQ7733XrRr1y6aNWuWtW359CEbhkgNGjSIO+64Iw455JBo2LBh3HnnnRu9EY+IyM/PzwrCI9Z/UVtEpM73+tFHH8WqVatin3322ei2rl27RllZWXzwwQeb/WfZ5fWn7fexxx7bal+i9umnn250v26JefPmRUlJSYVTiER88cWo5Tp16lThPv75z39m5lb+qn18ORgvD4bKg5/yUKhbt26pdX/00UexbNmyuP322+P222/f5HF/8IMfxBNPPBGHHnpodO7cOY499tg488wzo0+fPqn735SGDRtudK477rjjZgdXp59+elx++eXxyCOPxL333huDBg2q8He7OecaEXHXXXfFuHHjYu7cuVlhS0W/u6/6XRQWFsa1114bI0eOjNatW0evXr1i0KBBcdZZZ2VN8bApRx55ZNYXZA4dOjT22muvuOSSS2LWrFkRsf4xNGfOnEo/hipSVFQU69ati+Li4mjfvn18+OGHUVRUFK+//npWiL7vvvtmPvyaN29eREQmrP+y5s2bR0TE22+/HUmSxI9//OP48Y9/nFrjrrvumvn5q+7br/Ll++2r7LrrrhvN39y3b9/4+te/HldffXXccMMN0a9fvxg8eHCceeaZUVhYWOl9b6h8Tumbb7455s+fn/VdADvvvPNG47/qfih/Pd1rr72yxtWvX3+j1/wt8f7778dVV10Vf/nLXzb6HZTPs10dj/c0u+22Wxx99NGZn0888cTYeeed4/LLL48pU6bECSecsMntt+ZzddmyZfG3v/0tLr744qz56vv06RMPPvhgvPXWW7H33nvHRx99FMuXL9/ka/OGvvyak9Y7GzRoEHvssUfm9k6dOsVll10Wv/zlL+Pee++NoqKiOPHEE2PYsGGZgP20006L3//+93H++efHD3/4wzjqqKNiyJAhMXTo0KyA/svKP0zp06dP1lRBu+++exxxxBFZH+5taPHixTFw4MBo0aJF5kPP6ta9e/esx8iGtsZzGQBqEyE6ANu9/Pz86N+/f/zqV7+KefPmVWme0Mceeywi1s8ZO2/evArDPiI+//zzeOuttyodYFRGWVlZtGrVKvUq1y+HmhtezbnhPo455pi44oorKtxH+Ycd5dLCh8pcjbnhMSMihg0blnpFYPm8zl27do0333wzpkyZEo8++mg8+OCDcfPNN8dVV10VV199daWPWa66wpO2bdtGv379Yty4cfHcc8/Fgw8+WOG4zTnXe+65J84+++wYPHhwfP/7349WrVpFQUFBjB07Nt55551Kn8uGv4tLL700TjjhhJg8eXI89thj8eMf/zjGjh0bTz31VBx44IGbdc4R6/+a4rDDDouHHnoo82FTWVlZdO/ePfPdCF9WmXmxDz744GjYsGFMnz49dt9992jVqlXsvffeUVRUFDfffHOsWbMmZsyYkXW1f/l9e/fdd1cYNJbPVV0+7vLLL9/oLzHKlV/BW646Huebo6LnZl5eXkycODGef/75ePjhh+Oxxx6Lc889N8aNGxfPP/98NG3adLOPM2bMmPjxj38c5557bvz0pz/NzNl86aWXVnhFcE3fDxUpLS2NY445JpYuXRo/+MEPokuXLtGkSZNYuHBhnH322Vl1V/fjfVOOOuqoiIiYPn36V4boW/O5+sADD8SaNWti3LhxMW7cuI1uv/fee6v0WlnRY7Kyxo0bF2effXY89NBD8fjjj8d3vvOdGDt2bDz//POx2267RaNGjWL69Okxbdq0+Otf/xqPPvpo/OlPf4qvfe1r8fjjj6feX+Vz9lc0j32rVq0yf5WwoZKSkjjuuONi2bJlMWPGjI3m/a8JW+O5DAC1iRAdgDph3bp1EfHFn0l36NAhnnjiiVixYkXWlbVz587N3F7un//8Z1xzzTVxzjnnxCuvvBLnn39+vPbaaxv9GX9ZWVm8++67WYHsW2+9FRGR+oVpLVu2jMaNG8ebb7650W1z586N/Pz8TDhX0dXvacrrT9vvLrvsslWuQp84cWKsXr06NcSrij333DOeeOKJ6NOnT5UDjz333DM+/fTT1CvoNlf51aezZ89OHdOyZcto1qxZlJaWVuq4TZo0idNOOy1OO+20WLt2bQwZMiR+/vOfx6hRo6Jhw4bVUndVnHnmmXH++efHDjvsEMcff3yFYzbnXCdOnBh77LFHTJo0KesxPXr06C2qc88994yRI0fGyJEjY968edGjR48YN25c3HPPPVXa34avGU2aNIk999wzXn311TjqqKO+8rmYdnuDBg3i0EMPjRkzZsTuu++eme6iqKgo1qxZE/fee28sWbIkjjzyyKzzilgfnm3qvi1/TNavX7/aHuc1qVevXtGrV6/4+c9/HhMmTIj//u//jj/+8Y9x/vnnb9ZrX8T6x1j//v3jD3/4Q9b6ZcuWbdaV8+XKX0/nzZuX9RcBn3/+ecyfPz8OOOCAzd7nl7322mvx1ltvxV133RVnnXVWZv3UqVMrHP9Vj/fNvc/SfLl3VoeqPFfvvffe6NatW4WvE7fddltMmDAhrr766mjZsmU0b958k6/Nm7Jh79zwrwzWrl0b8+fP3+i51b179+jevXv86Ec/ipkzZ0afPn3i1ltvjZ/97GcRsf5D/KOOOiqOOuqo+OUvfxljxoyJ//mf/4lp06alPk+7d+8e9evX32j6pYj1X5r65Q+OP/vsszjhhBPirbfeiieeeCL23XffKp17ddnUcxkAtmXmRAdgu/f555/H448/Hg0aNMhM13L88cdHaWlp3HTTTVljb7jhhsjLy4vjjjsus+3ZZ58d7dq1i1/96lcxfvz4WLJkSXzve9+r8Fgb7i9Jkrjpppuifv36mav5vqygoCCOPfbYeOihh7KmfFmyZElMmDAhjjjiiMx0DeWh97Jly77ynNu2bRs9evSIu+66K2v87Nmz4/HHH08NQ7fEq6++GpdeemnsuOOOMWLEiGrb76mnnhqlpaXx05/+dKPb1q1bV6n749RTT43i4uLMXxRsaNmyZZmgqLJatmwZRx55ZNxxxx3x/vvvZ91WftVlQUFBfP3rX48HH3ywwkDno48+yvz/xx9/nHVbgwYNYt99940kSXI+t+zQoUNj9OjRcfPNN280FUe5zTnX8qsvN7w69YUXXoji4uIq1bdq1ar47LPPstbtueee0axZs1izZk2V9rl06dKYOXNmtGnTJjON0KmnnhoLFy6M3/3udxuNX716dWae84j1z9W0x2VRUVG88MILMW3atEyIvssuu0TXrl3j2muvzYwpN2DAgGjevHmMGTOmwsdC+X3bqlWr6NevX9x2222xaNGi1HG1zSeffLLRFd89evSIiMj8/ho3bhwRlXvti1j/GPvyPh944IEKQ8nKOPjgg6Nly5Zx6623xtq1azPrx48fX+mavkpFz4skSeJXv/pV1rjKPt439RjcHA8//HBERLV8UFDV5+oHH3wQ06dPj1NPPTWGDh260XLOOefE22+/HS+88ELk5+fH4MGD4+GHH46XXnppo3191V8XHH300dGgQYP49a9/nTX2D3/4Q5SUlMTAgQMjImL58uUb9Y3u3btHfn5+5lyWLl260f6//NiuSLNmzeL444+PmTNnZj7Yj4iYM2dOzJw5M4455pjMutLS0jjttNOiuLg4HnjggTj88MM3eX5bU2WeywCwLXMlOgDbnUceeSTzxvPDDz+MCRMmxLx58+KHP/xhJpA+4YQTon///vE///M/sWDBgjjggAPi8ccfj4ceeiguvfTSzNWfP/vZz+KVV16JJ598Mpo1axb7779/XHXVVfGjH/0ohg4dmhVGN2zYMB599NEYPnx4HHbYYfHII4/EX//617jyyitT51EuP8bUqVPjiCOOiG9/+9tRr169uO2222LNmjVZXyDWo0ePKCgoiGuvvTZKSkqisLAwvva1r6XOFX7dddfFcccdF4cffnicd955sXr16vjNb34TLVq0iJ/85CdbdB/PmDEjPvvss8yX9j333HPxl7/8JVq0aBF//vOft3hu3g317ds3Lrroohg7dmy88sorceyxx0b9+vVj3rx58cADD8SvfvWrGDp06Cb38f3vfz/+8pe/xKBBg+Lss8+Onj17xsqVK+O1116LiRMnxoIFCzb7CtVf//rXccQRR8RBBx0UF154YXTq1CkWLFgQf/3rX+OVV16JiIj//d//jWnTpsVhhx0WF1xwQey7776xdOnSePnll+OJJ57IhCzHHntstGnTJvr06ROtW7eOOXPmxE033RQDBw6s1vnlq6Kyj5fKnuugQYNi0qRJcfLJJ8fAgQNj/vz5ceutt8a+++5bpatd33rrrTjqqKPi1FNPjX333Tfq1asXf/7zn2PJkiVx+umnV2ofEydOjKZNm0aSJPHvf/87/vCHP8Qnn3wSt956a+aK3m984xtx//33xze/+c2YNm1a9OnTJ0pLS2Pu3Llx//33x2OPPZb5LoaePXvGE088Eb/85S+jXbt20alTpzjssMMiYn1A/vOf/zw++OCDrLD8yCOPjNtuuy06duwYu+22W2Z98+bN45ZbbolvfOMbcdBBB8Xpp58eLVu2jPfffz/++te/Rp8+fTIf3v32t7+NI444Irp37x4XXHBB7LHHHrFkyZIoLi6Of/3rX/Hqq69u9v27td11111x8803x8knnxx77rlnrFixIn73u99F8+bNM6+vjRo1in333Tf+9Kc/xd577x077bRTdOvWLXXaqEGDBmX+eqh3797x2muvxb333lvl+cvr168fP/vZz+Kiiy6Kr33ta3HaaafF/Pnz484779ysfb799tuZK5Q3dOCBB8axxx4be+65Z1x++eWxcOHCaN68eTz44IMbzY1e2cd7z54945Zbbomf/exn0blz52jVqlXqvPob7rv8avBVq1bF888/H3fddVd07tw5vvGNb1T6PDe1/6o8VydMmBBJksSJJ55Y4e3HH3981KtXL+6999447LDDYsyYMfH4449H375948ILL4yuXbvGokWL4oEHHohnn3028wWYFWnZsmWMGjUqrr766viv//qvOPHEE+PNN9+Mm2++OQ455JAYNmxYREQ89dRTcfHFF8cpp5wSe++9d6xbty7uvvvuzAeKERHXXHNNTJ8+PQYOHBgdOnSIDz/8MG6++ebYbbfdMl8cnGbMmDHx5JNPxte+9rXMF5n/+te/jp122imuvPLKzLiRI0fGX/7ylzjhhBNi6dKlG13NX15vTajMcxkAtmkJAGwn7rzzziQispaGDRsmPXr0SG655ZakrKwsa/yKFSuS733ve0m7du2S+vXrJ3vttVdy3XXXZcbNmjUrqVevXnLJJZdkbbdu3brkkEMOSdq1a5d88sknSZIkyfDhw5MmTZok77zzTnLssccmjRs3Tlq3bp2MHj06KS0tzdo+IpLRo0dnrXv55ZeTAQMGJE2bNk0aN26c9O/fP5k5c+ZG5/i73/0u2WOPPZKCgoIkIpJp06Zt8j554oknkj59+iSNGjVKmjdvnpxwwgnJG2+8kTVm2rRpSUQkDzzwwCb3teHY8qV+/fpJy5YtkyOPPDL5+c9/nnz44YcbbVP+e5k/f35mXfn99WV9+/ZN9ttvvwqPffvttyc9e/ZMGjVqlDRr1izp3r17csUVVyT//ve/M2M6dOiQDBw4sMLtV6xYkYwaNSrp3Llz0qBBg2SXXXZJevfunVx//fXJ2rVrkyRJkvnz5ycRkVx33XUbbV/R72327NnJySefnOywww5Jw4YNk3322Sf58Y9/nDVmyZIlyYgRI5L27dsn9evXT9q0aZMcddRRye23354Zc9tttyVHHnlksvPOOyeFhYXJnnvumXz/+99PSkpKKjyXcuX13nnnnZl1afft6NGjk8r8029Tv4NyaY+ZypxrWVlZMmbMmKRDhw5JYWFhcuCBByZTpkxJhg8fnnTo0GGjc/uq38V//vOfZMSIEUmXLl2SJk2aJC1atEgOO+yw5P777//Kcy2/TzZcmjRpkhx++OEVbr927drk2muvTfbbb7+ksLAw2XHHHZOePXsmV199ddbvau7cucmRRx6ZNGrUKImIZPjw4Znbli9fnhQUFCTNmjVL1q1bl1l/zz33JBGRfOMb36iw1mnTpiUDBgxIWrRokTRs2DDZc889k7PPPjt56aWXssa98847yVlnnZW0adMmqV+/frLrrrsmgwYNSiZOnJgZU/6c/Pvf/77RMSrzulJ+v3300UeptX55P2mPq5dffjk544wzkt133z0pLCxMWrVqlQwaNGij85o5c2bSs2fPpEGDBhU+Fzf02WefJSNHjkzatm2bNGrUKOnTp09SXFyc9O3bN+nbt+9GdX75cVzR8ypJkuTmm29OOnXqlBQWFiYHH3xwMn369I32maZDhw4bPdbKl/POOy9JkiR54403kqOPPjpp2rRpsssuuyQXXHBB8uqrr2bVUtnH++LFi5OBAwcmzZo1SyLiK2v8ck0FBQXJbrvtllx44YXJkiVLssbW9HO1e/fuye67777JMf369UtatWqVfP7550mSJMl7772XnHXWWUnLli2TwsLCZI899khGjBiRrFmzJkmS9OdAuZtuuinp0qVLUr9+/aR169bJt771rUy/T5Ikeffdd5Nzzz032XPPPZOGDRsmO+20U9K/f//kiSeeyIx58sknk5NOOilp165d0qBBg6Rdu3bJGWeckbz11lubPJdys2bNSo4++uikSZMmSbNmzZKTTjppo2379u2b+rja3Lf6AwcOzPq9bqgy/06o7HMZALZVeUlSg9+YAwDbqbPPPjsmTpxYrfPGAgAAALlnTnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASGFOdAAAAAAASLHNXIk+duzYOOSQQ6JZs2bRqlWrGDx4cLz55pub3Gb8+PGRl5eXtTRs2LCGKgaAukGPBoDaR38GgOqzzYTozzzzTIwYMSKef/75mDp1anz++edx7LHHxsqVKze5XfPmzWPRokWZ5b333quhigGgbtCjAaD20Z8BoPrUy3UBlfXoo49m/Tx+/Pho1apVzJo1K4488sjU7fLy8qJNmzZbuzwAqLP0aACoffRnAKg+28yV6F9WUlISERE77bTTJsd9+umn0aFDh2jfvn2cdNJJ8frrr9dEeQBQZ+nRAFD76M8AUHXb5BeLlpWVxYknnhjLli2LZ599NnVccXFxzJs3L/bff/8oKSmJ66+/PqZPnx6vv/567LbbbhVus2bNmlizZk3WsZYuXRo777xz5OXlVfu5AEB1SpIkVqxYEe3atYv8/Jr/rHxr9Wj9GYBtXS57tPfQAFCxSvfnZBv0zW9+M+nQoUPywQcfbNZ2a9euTfbcc8/kRz/6UeqY0aNHJxFhsVgsFss2vWxuj6wuW6tH688Wi8Vi2V6WXPRo76EtFovFYtn08lU9cpu7Ev3iiy+Ohx56KKZPnx6dOnXa7O1POeWUqFevXtx3330V3v7lT9FLSkpi9913jw8++CCaN29e5boBoCYsX7482rdvH8uWLYsWLVrU6LG3Zo/WnwHY1uWqR3sPDQDpKtuft5kvFk2SJC655JL485//HE8//XSVmn9paWm89tprcfzxx6eOKSwsjMLCwo3WN2/e3D8AANhm1OSfT9dEj9afAdhe1FSP9h4aACrvq/rzNhOijxgxIiZMmBAPPfRQNGvWLBYvXhwRES1atIhGjRpFRMRZZ50Vu+66a4wdOzYiIq655pro1atXdO7cOZYtWxbXXXddvPfee3H++efn7DwAYHujRwNA7aM/A0D12WZC9FtuuSUiIvr165e1/s4774yzzz47IiLef//9rAngP/nkk7jgggti8eLFseOOO0bPnj1j5syZse+++9ZU2QCw3dOjAaD20Z8BoPpsc3Oi17Tly5dHixYtoqSkxJ+iAVDr1ZW+VVfOE4DtR13pXXXlPAHYPlS2b+Wn3gIAAAAAAHWcEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACDFNhOijx07Ng455JBo1qxZtGrVKgYPHhxvvvnmV273wAMPRJcuXaJhw4bRvXv3+Nvf/lYD1QJA3aFHA0Dtoz8DQPXZZkL0Z555JkaMGBHPP/98TJ06NT7//PM49thjY+XKlanbzJw5M84444w477zz4h//+EcMHjw4Bg8eHLNnz67BygFg+6ZHA0Dtoz8DQPXJS5IkyXURVfHRRx9Fq1at4plnnokjjzyywjGnnXZarFy5MqZMmZJZ16tXr+jRo0fceuutlTrO8uXLo0WLFlFSUhLNmzevltoBYGupDX2rJnp0bThPANgcue5d3kMDwMYq27e2mSvRv6ykpCQiInbaaafUMcXFxXH00UdnrRswYEAUFxdv1doAoC7TowGg9tGfAaDq6uW6gKooKyuLSy+9NPr06RPdunVLHbd48eJo3bp11rrWrVvH4sWLU7dZs2ZNrFmzJvPz8uXLt7xgAKgjtlaP1p8BoOq8hwaALbNNXok+YsSImD17dvzxj3+s9n2PHTs2WrRokVnat29f7ccAgO3V1urR+jMAVJ330ACwZba5EP3iiy+OKVOmxLRp02K33Xbb5Ng2bdrEkiVLstYtWbIk2rRpk7rNqFGjoqSkJLN88MEH1VI3AGzvtmaP1p8BoGq8hwaALbfNhOhJksTFF18cf/7zn+Opp56KTp06feU2hx9+eDz55JNZ66ZOnRqHH3546jaFhYXRvHnzrAUASFcTPVp/BoDN4z00AFSfbWZO9BEjRsSECRPioYceimbNmmXmZGvRokU0atQoIiLOOuus2HXXXWPs2LEREfHd7343+vbtG+PGjYuBAwfGH//4x3jppZfi9ttvz9l5AMD2Ro8GgNpHfwaA6rPNXIl+yy23RElJSfTr1y/atm2bWf70pz9lxrz//vuxaNGizM+9e/eOCRMmxO233x4HHHBATJw4MSZPnrzJL1IBADaPHg0AtY/+DADVJy9JkiTXRdRmy5cvjxYtWkRJSYk/SwOg1qsrfauunCcA24+60rvqynkCsH2obN/aZq5EBwAAAACAmiZEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASLFNhejTp0+PE044Idq1axd5eXkxefLkTY5/+umnIy8vb6Nl8eLFNVMwANQB+jMA1E56NABUj20qRF+5cmUccMAB8dvf/naztnvzzTdj0aJFmaVVq1ZbqUIAqHv0ZwConfRoAKge9XJdwOY47rjj4rjjjtvs7Vq1ahU77LBD9RcEAOjPAFBL6dEAUD22qSvRq6pHjx7Rtm3bOOaYY+K5557LdTkAQOjPAFBb6dEAkG2buhJ9c7Vt2zZuvfXWOPjgg2PNmjXx+9//Pvr16xcvvPBCHHTQQRVus2bNmlizZk3m5+XLl9dUuQBQJ+jPAFA76dEAULHtOkTfZ599Yp999sn83Lt373jnnXfihhtuiLvvvrvCbcaOHRtXX311TZUIAHWO/gwAtZMeDQAVqxPTuWzo0EMPjbfffjv19lGjRkVJSUlm+eCDD2qwOgCom/RnAKid9GgA2M6vRK/IK6+8Em3btk29vbCwMAoLC2uwIgBAfwaA2kmPBoBtLET/9NNPsz4Bnz9/frzyyiux0047xe677x6jRo2KhQsXxv/93/9FRMSNN94YnTp1iv322y8+++yz+P3vfx9PPfVUPP7447k6BQDY7ujPAFA76dEAUD22qRD9pZdeiv79+2d+vuyyyyIiYvjw4TF+/PhYtGhRvP/++5nb165dGyNHjoyFCxdG48aNY//9948nnngiax8AwJbRnwGgdtKjAaB65CVJkuS6iNps+fLl0aJFiygpKYnmzZvnuhwA2KS60rfqynkCsP2oK72rrpwnANuHyvatOvfFogAAAAAAUFlCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIIUQHAAAAAIAU9XJdALBtWrVqVcydO7fK269evToWLFgQHTt2jEaNGlV5P126dInGjRtXeXsAAAAA2BQhOlAlc+fOjZ49e+a6jJg1a1YcdNBBuS4DAAAAgO2UEB2oki5dusSsWbOqvP2cOXNi2LBhcc8990TXrl23qA4AAAAA2FqE6ECVNG7cuFquAO/atasryQEAAACotXyxKAAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAECKelXdcOLEiXH//ffH+++/H2vXrs267eWXX97iwgAAAAAAINeqdCX6r3/96zjnnHOidevW8Y9//CMOPfTQ2HnnnePdd9+N4447rrprBAAAAACAnKhSiH7zzTfH7bffHr/5zW+iQYMGccUVV8TUqVPjO9/5TpSUlFR3jQAAAAAAkBNVCtHff//96N27d0RENGrUKFasWBEREd/4xjfivvvuq77qAAAAAAAgh6oUordp0yaWLl0aERG77757PP/88xERMX/+/EiSpPqqAwAAAACAHKpSiP61r30t/vKXv0RExDnnnBPf+9734phjjonTTjstTj755GotEAAAAAAAcqVeVTa6/fbbo6ysLCIiRowYETvvvHPMnDkzTjzxxLjooouqtUAAAAAAAMiVzQ7R161bF2PGjIlzzz03dtttt4iIOP300+P000+v9uIAAAAAACCXNns6l3r16sUvfvGLWLdu3daoBwAAAAAAao0qzYl+1FFHxTPPPFPdtQAAAAAAQK1SpTnRjzvuuPjhD38Yr732WvTs2TOaNGmSdfuJJ55YLcUBAAAAAEAuVSlE//a3vx0REb/85S83ui0vLy9KS0u3rCoAAAAAAKgFqhSil5WVVXcdAAAAAABQ61RpTvT/+7//izVr1my0fu3atfF///d/W1wUAAAAAADUBlUK0c8555woKSnZaP2KFSvinHPO2eKiAAAAAACgNqhSiJ4kSeTl5W20/l//+le0aNFii4sCAAAAAIDaYLPmRD/wwAMjLy8v8vLy4qijjop69b7YvLS0NObPnx//9V//Ve1FAgAAAABALmxWiD548OCIiHjllVdiwIAB0bRp08xtDRo0iI4dO8bXv/71ai0QAAAAAAByZbNC9NGjR0dERMeOHeO0006Lhg0bbpWiAAAAAACgNtisEL3c8OHDq7sOAAAAAACodSodou+0007x1ltvxS677BI77rhjhV8sWm7p0qXVUhwAAAAAAORSpUP0G264IZo1axYRETfeeOPWqgcAAAAAAGqNSofoG07hYjoXAAAAAADqgirNiV7uww8/jA8//DDKysqy1u+///5bVBQAAAAAANQGVQrRZ82aFcOHD485c+ZEkiRZt+Xl5UVpaWm1FAcAAAAAALmUX5WNzj333Nh7771j5syZ8e6778b8+fMzy7vvvlvdNWZMnz49TjjhhGjXrl3k5eXF5MmTv3Kbp59+Og466KAoLCyMzp07x/jx47dafQBQF+nPAFA76dEAUD2qFKK/++678Ytf/CIOO+yw6NixY3To0CFr2VpWrlwZBxxwQPz2t7+t1Pj58+fHwIEDo3///vHKK6/EpZdeGueff3489thjW61GAKhr9GcAqJ30aACoHlWazuWoo46KV199NTp37lzd9WzScccdF8cdd1ylx996663RqVOnGDduXEREdO3aNZ599tm44YYbYsCAAVurTACoU/RnAKid9GgAqB5VCtF///vfx/Dhw2P27NnRrVu3qF+/ftbtJ554YrUUt6WKi4vj6KOPzlo3YMCAuPTSS1O3WbNmTaxZsybz8/Lly7dWeQBQJ+nPAFA76dEAULEqhejFxcXx3HPPxSOPPLLRbbXpi0UXL14crVu3zlrXunXrWL58eaxevToaNWq00TZjx46Nq6++uqZKBIA6R3+G2qm0tDRmzJgRixYtirZt20ZRUVEUFBTkuiygBunRAFCxKs2Jfskll8SwYcNi0aJFUVZWlrXUlgC9qkaNGhUlJSWZ5YMPPsh1SQBQ5+nPsHVNmjQpOnfuHP37948zzzwz+vfvH507d45JkyblujSgltOjAagLqhSif/zxx/G9731vo0+oa5s2bdrEkiVLstYtWbIkmjdvXuEn6BERhYWF0bx586wFAKg++jPULpMmTYqhQ4dG9+7do7i4OFasWBHFxcXRvXv3GDp0qCAd6hA9GgAqVqUQfciQITFt2rTqrqXaHX744fHkk09mrZs6dWocfvjhOaoIANCfofYoLS2NkSNHxqBBg2Ly5MnRq1evaNq0afTq1SsmT54cgwYNissvv3yb/2tToHL0aACoWJXmRN97771j1KhR8eyzz0b37t03+mLR73znO9VS3Jd9+umn8fbbb2d+nj9/frzyyiux0047xe677x6jRo2KhQsXxv/93/9FRMQ3v/nNuOmmm+KKK66Ic889N5566qm4//77469//etWqQ8A6iL9GbZdM2bMiAULFsR9990X+fnZ19fk5+fHqFGjonfv3jFjxozo169fbooEqkyPBoDqUaUQ/fe//300bdo0nnnmmXjmmWeybsvLy9tqIfpLL70U/fv3z/x82WWXRUTE8OHDY/z48bFo0aJ4//33M7d36tQp/vrXv8b3vve9+NWvfhW77bZb/P73v48BAwZslfoAoC7Sn2HbtWjRooiI6NatW4W3l68vHwdsW/RoAKgeeUmSJLkuojZbvnx5tGjRIkpKSsztBtXo5Zdfjp49e8asWbPioIMOynU5sN2oK32rrpwnbG1PP/109O/fP4qLi6NXr14b3V5cXBy9e/eOadOmuRIdtlBd6V115TwB2D5Utm9VaU50AABg21dUVBQdO3aMMWPGRFlZWdZtZWVlMXbs2OjUqVMUFRXlqEIAAMi9LQ7R77vvvli5cmV11AIAANSggoKCGDduXEyZMiUGDx4cxcXFsWLFiiguLo7BgwfHlClT4vrrr4+CgoJclwoAADmzxSH6RRddFEuWLKmOWgAAgBo2ZMiQmDhxYrz22mvRu3fvaN68efTu3Ttmz54dEydOjCFDhuS6RAAAyKkqfbHohkypDgAA27YhQ4bESSedFDNmzIhFixZF27Zto6ioyBXoAAAQ1RCiR0Tk5eVVx24AAIAcKSgo8OWhAABQgc0O0c8999ysn9esWRNXXHFFNGvWLLPujjvu2PLKAAAAAAAgxzY7RO/QoUPWz3l5edGuXbvYaaedqq0oAAAAAACoDTY7RB89enTWz9dff31897vfjT322KPaigIAADbfqlWrYu7cuVXefvXq1bFgwYLo2LFjNGrUaItq6dKlSzRu3HiL9gEAALXBFs+Jbj50AACoHebOnRs9e/bMdRkRETFr1qw46KCDcl0GAABssS0O0ZMkqY46AACALdSlS5eYNWtWlbefM2dODBs2LO65557o2rXrFtcCAADbgy0O0R955JHYddddq6MWAABgCzRu3Lharv7u2rWrq8gBAOD/2+IQ/YgjjqiOOgAAAAAAoNbJr8pGf//73+OFF17YaP0LL7wQL7300hYXBQAAAAAAtUGVQvQRI0bEBx98sNH6hQsXxogRI7a4KAAAAAAAqA2qFKK/8cYbFc6ReOCBB8Ybb7yxxUUBAAAAAEBtUKU50QsLC2PJkiWxxx57ZK1ftGhR1Ku3xdOsAwAAAAARUVpaGjNmzIhFixZF27Zto6ioKAoKCnJdFtQpVboS/dhjj41Ro0ZFSUlJZt2yZcviyiuvjGOOOabaigMAAACAumrSpEnRuXPn6N+/f5x55pnRv3//6Ny5c0yaNCnXpUGdUqUQ/frrr48PPvggOnToEP3794/+/ftHp06dYvHixTFu3LjqrhEAAAAA6pRJkybF0KFDo3v37lFcXBwrVqyI4uLi6N69ewwdOlSQDjWoSnOv7LrrrvHPf/4z7r333nj11VejUaNGcc4558QZZ5wR9evXr+4aAQAAAKDOKC0tjZEjR8agQYNi8uTJkZ+//jrYXr16xeTJk2Pw4MFx+eWXx0knnWRqF6gBVQrRx44dG61bt44LL7wwa/0dd9wRH330UfzgBz+oluIAAAAAoK6ZMWNGLFiwIO67775MgF4uPz8/Ro0aFb17944ZM2ZEv379clMk1CFVms7ltttuiy5dumy0fr/99otbb711i4sCAAAAgLpq0aJFERHRrVu3Cm8vX18+Dti6qhSiL168ONq2bbvR+pYtW3ryAgAAAMAWKM/dZs+eXeHt5esryueA6lelEL19+/bx3HPPbbT+ueeei3bt2m1xUQAAAABQVxUVFUXHjh1jzJgxUVZWlnVbWVlZjB07Njp16hRFRUU5qhDqlirNiX7BBRfEpZdeGp9//nl87Wtfi4iIJ598Mq644ooYOXJktRYIAAAAAHVJQUFBjBs3LoYOHRqDBw+OUaNGRbdu3WL27NkxduzYmDJlSkycONGXikINqVKI/v3vfz8+/vjj+Pa3vx1r166NiIiGDRvGD37wgxg1alS1FggAAAAAdc2QIUNi4sSJMXLkyOjdu3dmfadOnWLixIkxZMiQHFYHdUuVQvS8vLy49tpr48c//nHMmTMnGjVqFHvttVcUFhZWd30AAAAAUCcNGTIkTjrppJgxY0YsWrQo2rZtG0VFRa5AhxpWpRC9XNOmTeOQQw6prloAAAAAgA0UFBREv379cl0G1GlV+mJRAAAAAACoC4ToAAAAAACQQogOAAAAAAAphOgAAAAAAJBCiA4AAAAAACmE6AAAAAAAkEKIDgAAAAAAKYToAAAAAACQQogOAAAAAAAp6uW6AAAAAACgYqWlpTFjxoxYtGhRtG3bNoqKiqKgoCDXZUGd4kp0AAAAAKiFJk2aFJ07d47+/fvHmWeeGf3794/OnTvHpEmTcl0a1ClCdAAAAACoZSZNmhRDhw6N7t27R3FxcaxYsSKKi4uje/fuMXToUEE61CAhOgAAAADUIqWlpTFy5MgYNGhQTJ48OXr16hVNmzaNXr16xeTJk2PQoEFx+eWXR2lpaa5LhTpBiA4AAAAAtciMGTNiwYIFceWVV0Z+fnZ8l5+fH6NGjYr58+fHjBkzclQh1C1CdAAAAACoRRYtWhQREd26davw9vL15eOArUuIDgAAAAC1SNu2bSMiYvbs2RXeXr6+fBywdQnRAQAAAKAWKSoqio4dO8aYMWOirKws67aysrIYO3ZsdOrUKYqKinJUIdQtQnQAAAAAqEUKCgpi3LhxMWXKlBg8eHAUFxfHihUrori4OAYPHhxTpkyJ66+/PgoKCnJdKtQJ9XJdAAAAAACQbciQITFx4sQYOXJk9O7dO7O+U6dOMXHixBgyZEgOq4O6RYgOAAAAALXQkCFD4qSTTooZM2bEokWLom3btlFUVOQKdKhhpnMBAAAAAIAUQnQAAAAAqIUmTZoUnTt3jv79+8eZZ54Z/fv3j86dO8ekSZNyXRrUKUJ0AAAAAKhlJk2aFEOHDo3u3btnfbFo9+7dY+jQoYJ0qEFCdAAAAACoRUpLS2PkyJExaNCgmDx5cvTq1SuaNm0avXr1ismTJ8egQYPi8ssvj9LS0lyXCnWCEB0AAAAAapEZM2bEggUL4sorr4z8/Oz4Lj8/P0aNGhXz58+PGTNm5KhCqFvq5boAIHfmzZsXK1asyMmx58yZk/XfXGjWrFnstddeOTs+AAAAVGTRokUREdGtW7cKby9fXz4O2LqE6FBHzZs3L/bee+9clxHDhg3L6fHfeustQToAAAC1Stu2bSMiYvbs2dGrV6+Nbp89e3bWOGDrEqJDHVV+Bfo999wTXbt2rfHjr169OhYsWBAdO3aMRo0a1fjx58yZE8OGDcvZlfgAAACQpqioKDp27BhjxoyJyZMnZ03pUlZWFmPHjo1OnTpFUVFRDquEukOIDnVc165d46CDDsrJsfv06ZOT4wIAAEBtVlBQEOPGjYuhQ4fG4MGDY9SoUdGtW7eYPXt2jB07NqZMmRITJ06MgoKCXJcKdYIQHQAAAABqmSFDhsTEiRNj5MiR0bt378z6Tp06xcSJE2PIkCE5rA7qFiE6AAAAANRCQ4YMiZNOOilmzJgRixYtirZt20ZRUZEr0KGGCdEBAAAAoJYqKCiIfv365boMqNPyv3oIAAAAAADUTUJ0AAAAAABIsc2F6L/97W+jY8eO0bBhwzjssMPixRdfTB07fvz4yMvLy1oaNmxYg9UCQN2hRwNA7aM/A8CW26ZC9D/96U9x2WWXxejRo+Pll1+OAw44IAYMGBAffvhh6jbNmzePRYsWZZb33nuvBisGgLpBjwaA2kd/BoDqsU2F6L/85S/jggsuiHPOOSf23XffuPXWW6Nx48Zxxx13pG6Tl5cXbdq0ySytW7euwYoBoG7QowGg9tGfAaB6bDMh+tq1a2PWrFlx9NFHZ9bl5+fH0UcfHcXFxanbffrpp9GhQ4do3759nHTSSfH6669v8jhr1qyJ5cuXZy0AQLqa6NH6MwBsHu+hAaD6bDMh+n/+858oLS3d6FPw1q1bx+LFiyvcZp999ok77rgjHnroobjnnnuirKwsevfuHf/6179SjzN27Nho0aJFZmnfvn21ngcAbG9qokfrzwCwebyHBoDqs82E6FVx+OGHx1lnnRU9evSIvn37xqRJk6Jly5Zx2223pW4zatSoKCkpySwffPBBDVYMAHXD5vZo/RkAtj7voQGgYvVyXUBl7bLLLlFQUBBLlizJWr9kyZJo06ZNpfZRv379OPDAA+Ptt99OHVNYWBiFhYVbVCsA1CU10aP1ZwDYPN5DA0D12WauRG/QoEH07Nkznnzyycy6srKyePLJJ+Pwww+v1D5KS0vjtddei7Zt226tMgGgztGjAaD20Z8BoPpsM1eiR0RcdtllMXz48Dj44IPj0EMPjRtvvDFWrlwZ55xzTkREnHXWWbHrrrvG2LFjIyLimmuuiV69ekXnzp1j2bJlcd1118V7770X559/fi5PAwC2O3o0ANQ++jMAVI9tKkQ/7bTT4qOPPoqrrroqFi9eHD169IhHH30080Up77//fuTnf3Fx/SeffBIXXHBBLF68OHbcccfo2bNnzJw5M/bdd99cnQIAbJf0aACoffRnAKgeeUmSJLkuojZbvnx5tGjRIkpKSqJ58+a5Lgeqzcsvvxw9e/aMWbNmxUEHHZTrcmpcXT9/tl91pW/VlfOEmqY/wtZTV3pXXTlPALYPle1b28yc6AAAAAAAUNOE6AAAAAAAkEKIDgAAAAAAKYToAAAAAACQQogOAAAAAAAphOgAAAAAAJBCiA4AAAAAACmE6AAAAAAAkEKIDgAAAAAAKerlugAAAOAL8+bNixUrVuTk2HPmzMn6b640a9Ys9tprr5zWAAAA5YToAABQS8ybNy/23nvvXJcRw4YNy3UJ8dZbbwnSAQCoFYToAABQS5RfgX7PPfdE165da/z4q1evjgULFkTHjh2jUaNGNX78iPVXwQ8bNixnV+MDAMCXCdEBAKCW6dq1axx00EE5OXafPn1yclwAAKitfLEoAAAAAACkEKIDAAAAAEAK07kAAAAAwFa0atWqmDt3bpW3r67vLenSpUs0bty4yttDXSVEBwAAAICtaO7cudGzZ89clxGzZs3K2feuwLZMiA4AAAAAW1GXLl1i1qxZVd5+zpw5MWzYsLjnnnuia9euW1QHsPmE6AAAAACwFTVu3LhargDv2rWrK8khB3yxKAAAAAAApBCiAwAAAABACiE6AAAAAACkMCc61GFtmuZFo2VvRfy77n2e1mjZW9GmaV6uywAAAACglhOiQx12Uc8G0XX6RRHTc11Jzesa688fAAAAADZFiA512G2z1sZpV42Prl265LqUGjdn7ty4bdyZcWKuCwEAAACgVhOiQx22+NMkVu+wd0S7HrkupcatXlwWiz9Ncl0GAAAAALVc3ZsIGQAAAAAAKkmIDgAAAAAAKYToAAAAAACQQogOAAAAAAApfLEoAADUIm2a5kWjZW9F/LtuXu/SaNlb0aZpXq7LAACADCE6AADUIhf1bBBdp18UMT3XleRG11h/HwAAQG0hRAcAgFrktllr47SrxkfXLl1yXUpOzJk7N24bd2acmOtCAADg/xOiAwBALbL40yRW77B3RLseuS4lJ1YvLovFnya5LgMAADLq5kSLAAAAAABQCUJ0AAAAAABIIUQHAAAAAIAUQnQAAAAAAEghRAcAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABIUS/XBQAAAABAbTdv3rxYsWJFTo49Z86crP/mQrNmzWKvvfbK2fEhl4ToAAAAALAJ8+bNi7333jvXZcSwYcNyevy33npLkE6dJEQHAAAAgE0ovwL9nnvuia5du9b48VevXh0LFiyIjh07RqNGjWr8+HPmzIlhw4bl7Ep8yDUhOgAAAABUQteuXeOggw7KybH79OmTk+MCvlgUAAAAAABSCdEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUtTLdQEAAAAAUNu1aZoXjZa9FfHvundNaqNlb0Wbpnm5LgNyRogOAAC1xKpVqyIi4uWXX87J8VevXh0LFiyIjh07RqNGjXJSw5w5c3JyXAD4Khf1bBBdp18UMT3XldS8rrH+/KGuEqIDAEAtMXfu3IiIuOCCC3JcSe41a9Ys1yUAQJbbZq2N064aH127dMl1KTVuzty5cdu4M+PEXBcCOSJEhzqqrl/p5io3AGqjwYMHR0REly5donHjxjV+/Dlz5sSwYcPinnvuia5du9b48cs1a9Ys9tprr5wdHwAqsvjTJFbvsHdEux65LqXGrV5cFos/TXJdBuTMNhei//a3v43rrrsuFi9eHAcccED85je/iUMPPTR1/AMPPBA//vGPY8GCBbHXXnvFtddeG8cff3wNVgy1kyvd1nOVG1QfPRq23C677BLnn39+rsuIrl27xkEHHZTrMoBqoD8DwJbbpkL0P/3pT3HZZZfFrbfeGocddljceOONMWDAgHjzzTejVatWG42fOXNmnHHGGTF27NgYNGhQTJgwIQYPHhwvv/xydOvWLQdnALWHK91c5QbVSY8GgNpHfwaA6pGXJMk287cYhx12WBxyyCFx0003RUREWVlZtG/fPi655JL44Q9/uNH40047LVauXBlTpkzJrOvVq1f06NEjbr311kodc/ny5dGiRYsoKSmJ5s2bV8+JAPHyyy9Hz549Y9asWa50g2qUq75V0z1af4atQ3+GrScXvct7aKg+db1H1vXzZ/tV2b61zVyJvnbt2pg1a1aMGjUqsy4/Pz+OPvroKC4urnCb4uLiuOyyy7LWDRgwICZPnrz5BaxcGVFQsPH6goKIhg2zx6XJz4/YcO7nzRm7alVE2ucdeXkRG15JvDljV6+OKCtLr6NJk6qN/eyziNLS6hnbuPH6uiMi1qyJWLeuesY2arT+fo6IWLs24vPPq2dsw4ZfPFY2Z+znn68fn6awMKJevc0fu27d+vsiTYMGEfXrb/7Y0tL1v7s09euvH58yNn/16mj8//8ba9d+MbasbP1jrTL7/aqx9eqtvy8i1j8n/v888Fs8dnOe914jKh7rNWLzx27O876G5bRH68+ee7Xpuac/V26s/rye14iqjd3WXyNqkPfQnn8R4flXjT26vEdm1VeDPTp1bA316Kx/I6xcqUenjfUasf7/t7XXiMpIthELFy5MIiKZOXNm1vrvf//7yaGHHlrhNvXr108mTJiQte63v/1t0qpVq9TjfPbZZ0lJSUlm+eCDD5KISErWP102Xo4/PnsHjRtXPC4iSfr2zR67yy7pYw8+OHtshw7pY/fdN3vsvvumj+3QIXvswQenj91ll+yxffumj23cOHvs8cenj/3yw27o0E2P/fTTL8YOH77psR9++MXYb39702Pnz/9i7OWXb3rs7NlfjB09etNjX3zxi7G/+MWmx06b9sXYm27a9NgpU74Ye+edmx57//1fjL3//k2PvfPOL8ZOmbLpsTfd9MXYadM2PfYXv/hi7Isvbnrs6NFfjJ09e9NjL7/8i7Hz52967Le//cXYDz/c9Njhw78Y++mnmx47dGiSZVNjvUasX7xGfLFs5deIkpKSJCKSkpKSpKbURI/Wnz33avtzL0kS/bmc/vwFrxHreY1IkiRJSm6+OanJHu09dAfPvyTx/CtXjT16/ob9UY9eT4/+gteI9bah14jKvofOr3zcXjeMHTs2WrRokVnat2+f65IAoM7TnwGgdtKjAagLtpk50deuXRuNGzeOiRMnZr4QMSJi+PDhsWzZsnjooYc22mb33XePyy67LC699NLMutGjR8fkyZPj1VdfrfA4a9asiTUb/CnO8uXLo3379lHy739XPC+OPzOpeKw/M9n8sXXsz8VfeeWV6HPEEfHcs89Gj0MO8efiEV4jqjrWa8R6//95n4t5SGuiR+vPX+K5t/lj9ef19OfNH+s1ompjvUast8HzfvnHH0eLXXapsR7tPbTnX0R4/lVjj545c2Ycc+yx8etbbokDDz00MzZ/E/WW1auX1aPzN1FDUq9eJJsYu3r16njvvfeiQ4cO0bBZsy/GlpVF/ib+nZC1368aW1AQSXk/T5LI3+DfCXPnzo3zzj9//b8RevTQo9PGeo1Y///b0GvEdjcneoMGDaJnz57x5JNPZv4BUFZWFk8++WRcfPHFFW5z+OGHx5NPPpn1D4CpU6fG4YcfnnqcwsLCKCx/EdhQkybZD8g0lRlTlbEbPiGrc+yGLyDVOXbDF7zqHFtY+MWLdHWObdDgizd+uRpbv/4XzbU6x9arV/k5njZnbEFB5R/DFYwta9QoVv3//2bdR/n5ld/v5ozNy9s6YyNqx1ivEet5jciJmujR+nM1jfXc2/yx+vN6+nPVxnqNWM9rxBdja5D30J5/EeH5V5WxKX33jffei1URcf63vlW5/WynmrRqtfFzUY/+gteI9ba114hK2GZC9IiIyy67LIYPHx4HH3xwHHrooXHjjTfGypUr45xzzomIiLPOOit23XXXGDt2bEREfPe7342+ffvGuHHjYuDAgfHHP/4xXnrppbj99ttzeRoAsN3RowGg9tGfofqUfxjVpUuXaLw5oWo1mTNnTgwbNizuueee6Nq1a40fPyKiWbNmsddee+Xk2JBr21SIftppp8VHH30UV111VSxevDh69OgRjz76aLRu3ToiIt5///3Iz/9imvfevXvHhAkT4kc/+lFceeWVsddee8XkyZOjW7duuToFANgu6dEAUPvoz1B9dtlllzj//PNzXUZ07do1DjrooFyXAXXONjMneq7kYm5ZqAtefvnl6NmzZ8yaNcs/AKAa1ZW+VVfOE2qa/gxbT13pXXXlPKGm6dGwdVS2b+Wn3gIAAAAAAHWcEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFLUy3UBwLZp1apVMXfu3CpvP2fOnKz/VlWXLl2icePGW7QPAAAAAEgjRAeqZO7cudGzZ88t3s+wYcO2aPtZs2bFQQcdtMV1AAAAAEBFhOhAlXTp0iVmzZpV5e1Xr14dCxYsiI4dO0ajRo22qA4AAAAA2FqE6ECVNG7ceIuvAO/Tp081VQMAAAAAW4cvFgUAAAAAgBRCdAAAAAAASCFEBwAAAACAFEJ0AAAAAABI4YtFAQBgO7Fq1aqYO3dulbefM2dO1n+3RJcuXaJx48ZbvB8A2B7Ulh6tP0PVCNEBAGA7MXfu3OjZs+cW72fYsGFbvI9Zs2bFQQcdtMX7AYDtQW3p0fozVI0QHQAAthNdunSJWbNmVXn71atXx4IFC6Jjx47RqFGjLa4FAFivtvRo/RmqRogOAADbicaNG2/x1WV9+vSppmoAgHJ6NGzbfLEoAAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApNhmQvSlS5fGf//3f0fz5s1jhx12iPPOOy8+/fTTTW7Tr1+/yMvLy1q++c1v1lDFAFA36NEAUPvozwBQferluoDK+u///u9YtGhRTJ06NT7//PM455xz4sILL4wJEyZscrsLLrggrrnmmszPjRs33tqlAkCdokcDQO2jPwNA9dkmQvQ5c+bEo48+Gn//+9/j4IMPjoiI3/zmN3H88cfH9ddfH+3atUvdtnHjxtGmTZuaKhUA6hQ9GgBqH/0ZAKrXNjGdS3Fxceywww6Z5h8RcfTRR0d+fn688MILm9z23nvvjV122SW6desWo0aNilWrVm3tcgGgztCjAaD20Z8BoHptE1eiL168OFq1apW1rl69erHTTjvF4sWLU7c788wzo0OHDtGuXbv45z//GT/4wQ/izTffjEmTJqVus2bNmlizZk3m55KSkoiIWL58+RaeBQBsfeX9KkmSGjleTfVo/RmAbV1N9mjvoQGgcirbn3Maov/whz+Ma6+9dpNj5syZU+X9X3jhhZn/7969e7Rt2zaOOuqoeOedd2LPPfescJuxY8fG1VdfvdH69u3bV7kOAKhpK1asiBYtWlR5+9rWo/VnALYXW9Kja1t/jtCjAdg+fFV/zktq6lK1Cnz00Ufx8ccfb3LMHnvsEffcc0+MHDkyPvnkk8z6devWRcOGDeOBBx6Ik08+uVLHW7lyZTRt2jQeffTRGDBgQIVjvvwpellZWSxdujR23nnnyMvLq9RxgK+2fPnyaN++fXzwwQfRvHnzXJcD240kSWLFihXRrl27yM+v+qxtta1H689QM/Rn2Hqqo0fXtv4coUdDTdGjYeuobH/O6ZXoLVu2jJYtW37luMMPPzyWLVsWs2bNip49e0ZExFNPPRVlZWVx2GGHVfp4r7zySkREtG3bNnVMYWFhFBYWZq3bYYcdKn0MYPM0b97cPwCgmm3JFejlaluP1p+hZunPsHVsaY+ubf05Qo+GmqZHQ/WrTH/eJr5YtGvXrvFf//VfccEFF8SLL74Yzz33XFx88cVx+umnZ75VfOHChdGlS5d48cUXIyLinXfeiZ/+9Kcxa9asWLBgQfzlL3+Js846K4488sjYf//9c3k6ALDd0KMBoPbRnwGgem0TIXrE+m8I79KlSxx11FFx/PHHxxFHHBG333575vbPP/883nzzzcw3hzdo0CCeeOKJOPbYY6NLly4xcuTI+PrXvx4PP/xwrk4BALZLejQA1D76MwBUn5zOiQ7UXWvWrImxY8fGqFGjNvrzTwAgN/RnAKid9GjILSE6AAAAAACk2GamcwEAAAAAgJomRAcAAAAAgBRCdAAAAAAASCFEB2rU9OnT44QTToh27dpFXl5eTJ48OdclAQChRwNAbaQ/Q+0gRAdq1MqVK+OAAw6I3/72t7kuBQDYgB4NALWP/gy1Q71cFwDULccdd1wcd9xxuS4DAPgSPRoAah/9GWoHV6IDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABAinq5LgCoWz799NN4++23Mz/Pnz8/Xnnlldhpp51i9913z2FlAFC36dEAUPvoz1A75CVJkuS6CKDuePrpp6N///4brR8+fHiMHz++5gsCACJCjwaA2kh/htpBiA4AAAAAACnMiQ4AAAAAACmE6AAAAAAAkEKIDgAAAAAAKYToAAAAAACQQogOAAAAAAAphOgAAAAAAJBCiA4AAAAAACmE6AAAAAAAkEKIDgAAAAAAKYToAAAAAACQQogOAAAAAAAphOgAAAAAAJBCiA4AAAAAACmE6AAAAAAAkEKIDgAAAAAAKYToAAAAAACQQogOAAAAAAAphOgAAAAAAJBimwnRx44dG4ccckg0a9YsWrVqFYMHD44333xzk9uMHz8+8vLyspaGDRvWUMUAUDfo0QBQ++jPAFB9tpkQ/ZlnnokRI0bE888/H1OnTo3PP/88jj322Fi5cuUmt2vevHksWrQos7z33ns1VDEA1A16NADUPvozAFSferkuoLIeffTRrJ/Hjx8frVq1ilmzZsWRRx6Zul1eXl60adNma5cHAHWWHg0AtY/+DADVZ5u5Ev3LSkpKIiJip5122uS4Tz/9NDp06BDt27ePk046KV5//fWaKA8A6iw9GgBqH/0ZAKouL0mSJNdFbK6ysrI48cQTY9myZfHss8+mjisuLo558+bF/vvvHyUlJXH99dfH9OnT4/XXX4/ddtutwm3WrFkTa9asyTrW0qVLY+edd468vLxqPxcAqE5JksSKFSuiXbt2kZ9f85+Vb60erT8DsK3LZY/2HhoAKlbp/pxsg775zW8mHTp0SD744IPN2m7t2rXJnnvumfzoRz9KHTN69OgkIiwWi8Vi2aaXze2R1WVr9Wj92WKxWCzby5KLHu09tMVisVgsm16+qkduc1eiX3zxxfHQQw/F9OnTo1OnTpu9/SmnnBL16tWL++67r8Lbv/wpeklJSey+++7xwQcfRPPmzatcNwDUhOXLl0f79u1j2bJl0aJFixo99tbs0fozANu6XPVo76EBIF1l+/M288WiSZLEJZdcEn/+85/j6aefrlLzLy0tjddeey2OP/741DGFhYVRWFi40frmzZv7BwAA24ya/PPpmujR+jMA24ua6tHeQwNA5X1Vf95mQvQRI0bEhAkT4qGHHopmzZrF4sWLIyKiRYsW0ahRo4iIOOuss2LXXXeNsWPHRkTENddcE7169YrOnTvHsmXL4rrrrov33nsvzj///JydBwBsb/RoAKh99GcAqD7bTIh+yy23REREv379stbfeeedcfbZZ0dExPvvv581Afwnn3wSF1xwQSxevDh23HHH6NmzZ8ycOTP23XffmiobALZ7ejQA1D76MwBUn21uTvSatnz58mjRokWUlJT4UzQAar260rfqynkCsP2oK72rrpwnANuHyvat/NRbAAAAAACgjhOiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKQQogMAAAAAQAohOgAAAAAApBCiAwAAAABACiE6AAAAAACkEKIDAAAAAEAKIToAAAAAAKSol+sCgLqntLQ0ZsyYEYsWLYq2bdtGUVFRFBQU5LosAAAAANiIK9GBGjVp0qTo3Llz9O/fP84888zo379/dO7cOSZNmpTr0gAAAABgI0J0oMZMmjQphg4dGt27d4/i4uJYsWJFFBcXR/fu3WPo0KGCdAAAAABqHSE6UCNKS0tj5MiRMWjQoJg8eXL06tUrmjZtGr169YrJkyfHoEGD4vLLL4/S0tJclwoAAAAAGUJ0oEbMmDEjFixYEFdeeWXk52e/9OTn58eoUaNi/vz5MWPGjBxVCAAAAAAbE6IDNWLRokUREdGtW7cKby9fXz4OAAAAAGoDITpQI9q2bRsREbNnz67w9vL15eMAAAAAoDYQogM1oqioKDp27BhjxoyJsrKyrNvKyspi7Nix0alTpygqKspRhQAAAACwMSE6UCMKCgpi3LhxMWXKlBg8eHAUFxfHihUrori4OAYPHhxTpkyJ66+/PgoKCnJdKgAAAABkbDMh+tixY+OQQw6JZs2aRatWrWLw4MHx5ptvfuV2DzzwQHTp0iUaNmwY3bt3j7/97W81UC1QkSFDhsTEiRPjtddei969e0fz5s2jd+/eMXv27Jg4cWIMGTIk1yUCVaBHA0Dtoz8DQPXZZkL0Z555JkaMGBHPP/98TJ06NT7//PM49thjY+XKlanbzJw5M84444w477zz4h//+EcMHjw4Bg8enDonM7D1DRkyJN5+++2YNm1aTJgwIaZNmxbz5s0ToMM2TI8GgNpHfwaA6pOXJEmS6yKq4qOPPopWrVrFM888E0ceeWSFY0477bRYuXJlTJkyJbOuV69e0aNHj7j11lsrdZzly5dHixYtoqSkJJo3b14ttQPA1lIb+lZN9OjacJ4AsDly3bu8hwaAjVW2b20zV6J/WUlJSURE7LTTTqljiouL4+ijj85aN2DAgCguLk7dZs2aNbF8+fKsBQCovK3Ro/VnANgy3kMDQNVtkyF6WVlZXHrppdGnT5/o1q1b6rjFixdH69ats9a1bt06Fi9enLrN2LFjo0WLFpmlffv21VY3AGzvtlaP1p8BoOq8hwaALbNNhugjRoyI2bNnxx//+Mdq3/eoUaOipKQks3zwwQfVfgwA2F5trR6tPwNA1XkPDQBbpl6uC9hcF198cUyZMiWmT58eu+222ybHtmnTJpYsWZK1bsmSJdGmTZvUbQoLC6OwsLBaagWAumRr9mj9GQCqxntoANhy28yV6EmSxMUXXxx//vOf46mnnopOnTp95TaHH354PPnkk1nrpk6dGocffvjWKhMA6hw9GgBqH/0ZAKrPNnMl+ogRI2LChAnx0EMPRbNmzTJzsrVo0SIaNWoUERFnnXVW7LrrrjF27NiIiPjud78bffv2jXHjxsXAgQPjj3/8Y7z00ktx++235+w8AGB7o0cDQO2jPwNA9dlmrkS/5ZZboqSkJPr16xdt27bNLH/6058yY95///1YtGhR5ufevXvHhAkT4vbbb48DDjggJk6cGJMnT97kF6kAAJtHjwaA2kd/BoDqk5ckSZLrImqz5cuXR4sWLaKkpCSaN2+e63IAYJPqSt+qK+cJwPajrvSuunKeAGwfKtu3tpkr0QEAAAAAoKYJ0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABSCNEBAAAAACCFEB0AAAAAAFII0QEAAAAAIIUQHQAAAAAAUgjRAQAAAAAghRAdAAAAAABS1Mt1AQAAQO6VlpbGjBkzYtGiRdG2bdsoKiqKgoKCXJcFAAA550p0AACo4yZNmhSdO3eO/v37x5lnnhn9+/ePzp07x6RJk3JdGgAA5JwQHQAA6rBJkybF0KFDo3v37lFcXBwrVqyI4uLi6N69ewwdOlSQDgBAnSdEBwCAOqq0tDRGjhwZgwYNismTJ0evXr2iadOm0atXr5g8eXIMGjQoLr/88igtLc11qQAAkDNCdAAAqKNmzJgRCxYsiCuvvDLy87PfGuTn58eoUaNi/vz5MWPGjBxVCAAAuSdEBwCAOmrRokUREdGtW7cKby9fXz4OAADqIiE6AADUUW3bto2IiNmzZ1d4e/n68nEAAFAXCdEBAKCOKioqio4dO8aYMWOirKws67aysrIYO3ZsdOrUKYqKinJUIQAA5J4QHQAA6qiCgoIYN25cTJkyJQYPHhzFxcWxYsWKKC4ujsGDB8eUKVP+H3v3Hh9VfeeP/x0uhkQhahEBi4YWbKKCmKByEcGtW1frhVK/a1UKtYVtt9pWwbrFtbrWXbPbVmu39Vpr2ZZatZTS39KuW0URVFrWIFV2E8EKyrYEbzUIxKDJ/P5gCaZwMAmTnAnzfD4e8zA58z5z3oPMvJlXTj4nvvnNb0bPnj3TbhUAAFLTK+0GAACA9EyZMiXmz58fs2fPjnHjxrVsHzp0aMyfPz+mTJmSYncAAJA+IToAAOS5KVOmxHnnnRfLli2LjRs3xqBBg2LChAnOQAcAgBCiAwAAsWNpl0mTJqXdBgAA5BxrogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJOiVdgMAAAAAwJ41NTXFsmXLYuPGjTFo0KCYMGFC9OzZM+22IK84Ex0AAAAActCCBQti2LBhcdppp8VFF10Up512WgwbNiwWLFiQdmuQV4ToAAAAAJBjFixYEOeff36MGDEili9fHm+++WYsX748RowYEeeff74gHbqQEB0AAAAAckhTU1PMnj07zj777Fi4cGGMGTMmDjrooBgzZkwsXLgwzj777Ljyyiujqakp7VYhLwjRAQCAaGpqiiVLlsRPfvKTWLJkiQ/lAJCiZcuWxfr16+Pqq6+OHj1ax3c9evSIOXPmxLp162LZsmUpdQj5RYgOAAB5znqrAJBbNm7cGBERxx133B7v37l9Zx3QuYToAACQx6y3CgC5Z9CgQRERsXr16j3ev3P7zjqgcxVkMplM2k3kss2bN0dJSUnU19dHv3790m4HAPYqX+ZWvjxP6GxNTU0xbNiwGDFiRCxcuLDVr4s3NzfH5MmTY/Xq1bF27dro2bNnip1C95cvsytfnid0NjMaukZb55Yz0QEAIE9ZbxUAclPPnj3jpptuikWLFsXkyZNb/bbY5MmTY9GiRfHNb35TgA5dpFfaDQAAAOmw3ioA5K4pU6bE/PnzY/bs2TFu3LiW7UOHDo358+fHlClTUuwO8osQHQAA8tS711sdM2bMbvdbbxUA0jVlypQ477zzYtmyZbFx48YYNGhQTJgwwRno0MWE6AAAkKcmTJgQpaWlceONN+5xvdWqqqoYOnRoTJgwIcUuASC/9ezZMyZNmpR2G5DXrIkOAAB5ynqrAADw3pyJDgAAecx6qwAAsHdCdAAAyHPWWwUAgGRCdAAAwHqrAACQwJroAAAAAACQQIgOAAAAAAAJulWIvnTp0jjnnHNi8ODBUVBQEAsXLtxr/ZIlS6KgoGC3W11dXdc0DAB5wHwGgNxkRgNAdnSrEH3r1q1x/PHHx6233tqu/Z577rnYuHFjy23AgAGd1CEA5B/zGQBykxkNANnRrS4seuaZZ8aZZ57Z7v0GDBgQBx98cPYbgjy2bdu2qK2t7fD+DQ0NsX79+igtLY2ioqIOP05ZWVkUFxd3eH9g35nPAJCbzGgAyI5uFaJ31KhRo6KxsTGOO+64+Id/+IcYP358Ym1jY2M0Nja2fL958+auaBG6ndra2qisrEy7jaiuro6Kioq02wA6wHwGgNxkRgNAa/t1iD5o0KC44447YvTo0dHY2Bh33313TJo0KX77298mhm5VVVVx/fXXd3Gn0P2UlZVFdXV1h/evqamJqVOnxrx586K8vHyf+gC6F/MZAHKTGQ0Ae1aQyWQyaTfREQUFBfHzn/88Jk+e3K79Jk6cGEceeWT86Ec/2uP9e/op+pAhQ6K+vj769eu3Ly0D77Jy5cqorKx0Jjlk2ebNm6OkpCS1uWU+A8CemdEAkHvaOp/36zPR9+Skk06Kxx9/PPH+wsLCKCws7MKOAADzGQBykxkNABE90m6gq61atSoGDRqUdhsAwLuYzwCQm8xoAOhmZ6Jv2bIlnn/++Zbv161bF6tWrYpDDz00jjzyyJgzZ0784Q9/iB/+8IcREXHLLbfE0KFD49hjj4233nor7r777njkkUfi17/+dVpPAQD2O+YzAOQmMxoAsqNbhehPPfVUnHbaaS3fz5o1KyIipk+fHnPnzo2NGzfGSy+91HL/9u3bY/bs2fGHP/whiouLY+TIkfHwww+3egwAYN+YzwCQm8xoAMiObnth0a6S9sVfYH/lwqLQOfJlbuXL8wRg/5EvsytfnicA+4e2zq28WxMdAAAAAADaSogOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACYToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACYToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACYToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACYToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAl6pd0AAAAAAOzPtm3bFrW1tR3ev6GhIdavXx+lpaVRVFTU4ccpKyuL4uLiDu8P+UqIDgAAAACdqLa2NiorK9NuI6qrq6OioiLtNqDbEaIDAAAAQCcqKyuL6urqDu9fU1MTU6dOjXnz5kV5efk+9QG0nxAdAAAAADpRcXFxVs4ALy8vdyY5pMCFRQEAAAAAIIEQHQAAAAAAEgjRAQAAAAAggRAdAAAAAAASuLAoAADsJ7Zt2xa1tbUd3r+hoSHWr18fpaWlUVRUtE+9lJWVRXFx8T49BgAA5AIhOgAA7Cdqa2ujsrIy7TYiIqK6ujoqKirSbgMAAPaZEB0AAPYTZWVlUV1d3eH9a2pqYurUqTFv3rwoLy/f514AAGB/sE8h+vbt2+Pll1+O5ubmVtuPPPLIfWoKAABov+Li4qyc/V1eXu4scgAA+D8dCtHXrl0bn/70p+PJJ59stT2TyURBQUE0NTVlpTkAAAAAAEhTh0L0T33qU9GrV69YtGhRDBo0KAoKCrLdFwAAAAAApK5DIfqqVauiurraOocAAAAAAOzXenRkp2OOOSZeffXVbPcCAAAAAAA5pUMh+r/8y7/EVVddFUuWLInXXnstNm/e3OoGAAAAAAD7gw4t53L66adHRMSHP/zhVttdWBQAAAAAgP1Jh0L0Rx99NNt9AAAAAABAzulQiD5x4sRs9wEAAAAAADmnQyF6RMQbb7wR3//+96OmpiYiIo499tj49Kc/HSUlJVlrDgAAAAAA0tShC4s+9dRT8cEPfjC+9a1vxeuvvx6vv/563HzzzfHBD34wVq5cme0eAQAAAAAgFR06E/2KK66Ic889N773ve9Fr147HuKdd96JGTNmxOWXXx5Lly7NapMAAAAAAJCGDoXoTz31VKsAPSKiV69ecdVVV8Xo0aOz1hwAAAAAAKSpQ8u59OvXL1566aXdtm/YsCH69u27z00BAAAAAEAu6FCIfsEFF8RnPvOZuP/++2PDhg2xYcOGuO+++2LGjBlx4YUXZrtHAAAAAABIRYeWc/nmN78ZBQUFMW3atHjnnXciIqJ3797xt3/7t/HP//zPWW0QAAAAAADS0qEQ/YADDohvf/vbUVVVFb///e8jIuKDH/xgFBcXZ7U5AAAAAABIU4eWc9mpuLg4RowYEUcddVT8+te/jpqammz1BQAAAAAAqetQiP7Xf/3X8d3vfjciIhoaGmL06NHx13/91zFy5Mj42c9+ltUGAQAAAAAgLR0K0ZcuXRoTJkyIiIif//znkclk4o033oh//dd/jX/8x3/MaoMAAAAAAJCWDoXo9fX1ceihh0ZExIMPPhgf//jHo7i4OD760Y/G2rVrs9ogAAAAAACkpUMh+pAhQ2L58uWxdevWePDBB+MjH/lIRET86U9/ij59+mS1QQAAAAAASEuHQvTLL788Lr744nj/+98fgwcPjkmTJkXEjmVeRowYkc3+Wlm6dGmcc845MXjw4CgoKIiFCxe+5z5LliyJioqKKCwsjGHDhsXcuXM7rT8AyEfmMwDkJjMaALKjQyH65z//+Vi+fHncc8898fjjj0ePHjse5gMf+ECnrom+devWOP744+PWW29tU/26deviox/9aJx22mmxatWquPzyy2PGjBnxn//5n53WIwDkG/MZAHKTGQ0A2dGrozuOHj06Ro8e3WrbRz/60X1uaG/OPPPMOPPMM9tcf8cdd8TQoUPjpptuioiI8vLyePzxx+Nb3/pWnHHGGZ3VJgDkFfMZAHKTGQ0A2dHmEH3WrFlxww03xIEHHhizZs3aa+3NN9+8z41lw/Lly+P0009vte2MM86Iyy+/PJ2GAADzGQBylBkNAHvW5hD96aefjrfffrvl6yQFBQX73lWW1NXVxeGHH95q2+GHHx6bN2+OhoaGKCoq2m2fxsbGaGxsbPl+8+bNnd4nAOQT8xkAcpMZDQB71uYQ/dFHH93j1/ubqqqquP7669NuAwB4F/MZAHKTGQ1APujQhUXfbcOGDbFhw4Zs9JJ1AwcOjE2bNrXatmnTpujXr98ef4IeETFnzpyor69vueXqcwOA7sp8BoDcZEYDwJ51KER/55134qtf/WqUlJREaWlplJaWRklJSVxzzTUtS77kgrFjx8bixYtbbXvooYdi7NixifsUFhZGv379Wt0AgOwxnwEgN5nRALBnHQrRv/CFL8Rdd90VX//61+Ppp5+Op59+Or7+9a/H97///fjiF7+Y7R5bbNmyJVatWhWrVq2KiIh169bFqlWr4qWXXoqIHT8BnzZtWkv95z73uXjhhRfiqquuitra2rjtttvigQceiCuuuKLTegSAfGM+A0BuMqMBIDvavCb6u917771x3333xZlnntmybeTIkTFkyJC48MIL4/bbb89ag+/21FNPxWmnndby/axZsyIiYvr06TF37tzYuHFjyz8GIiKGDh0av/zlL+OKK66Ib3/72/H+978/7r777jjjjDM6pT8AyEfmMwDkJjMaALKjQyF6YWFhlJaW7rZ96NChccABB+xrT4kmTZoUmUwm8f65c+fucZ+nn36603oCgHxnPgNAbjKjASA7OrScy2WXXRY33HBDNDY2tmxrbGyMf/qnf4rLLrssa80BAAAAAECa2nwm+pQpU1p9//DDD8f73//+OP744yMi4ne/+11s3749PvzhD2e3QwAAAAAASEmbQ/SSkpJW33/84x9v9f2QIUOy0xEAAAAAAOSINofoP/jBDyIiIpPJxIYNG+Kwww6LoqKiTmsMAAAAAADS1u410TOZTAwbNiz+93//tzP6AQAAAACAnNHuEL1Hjx4xfPjweO211zqjHwAAAAAAyBntDtEjIv75n/85vvzlL8fq1auz3Q8AAAAAAOSMNq+J/m7Tpk2Lbdu2xfHHHx8HHHDAbmujv/7661lpDgAAAAAA0tShEP2WW27JchsAAAAAAJB7OhSiT58+Pdt9AAAAAABAzulQiP5ub731Vmzfvr3Vtn79+u3rwwIAAAAAQOo6dGHRrVu3xmWXXRYDBgyIAw88MA455JBWNwAAAAAA2B90KES/6qqr4pFHHonbb789CgsL4+67747rr78+Bg8eHD/84Q+z3SMAAAAAAKSiQ8u5/Pu//3v88Ic/jEmTJsUll1wSEyZMiGHDhsVRRx0VP/7xj+Piiy/Odp8AAAAAANDlOnQm+uuvvx4f+MAHImLH+uevv/56RESccsopsXTp0ux1BwAAAAAAKepQiP6BD3wg1q1bFxERZWVl8cADD0TEjjPUDz744Kw1BwAAAAAAaepQiH7JJZfE7373u4iI+MpXvhK33npr9OnTJ6644or48pe/nNUGAQAAAAAgLR1aE/2KK65o+fr000+P2traqK6ujmHDhsXIkSOz1hwAAAAAAKSpQyF6RMTixYtj8eLF8fLLL0dzc3Or++655559bgwAAAAAANLWoRD9+uuvj6997WsxevToGDRoUBQUFGS7LwAAAAAASF2HQvQ77rgj5s6dG5/85Cez3Q8AAAAAAOSMDl1YdPv27TFu3Lhs9wIAAAAAADmlQyH6jBkz4t577812LwAAAAAAkFPavJzLrFmzWr5ubm6Ou+66Kx5++OEYOXJk9O7du1XtzTffnL0OAQAAAAAgJW0O0Z9++ulW348aNSoiIlavXt1qu4uMAgAAAACwv2hziP7oo492Zh8AAAAAAJBzOrQmOgAAAAAA5AMhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACTolXYDQHrWrl0bb775ZirHrqmpafXfNPTt2zeGDx+e2vEBAAAAyH1CdMhTa9eujaOPPjrtNmLq1KmpHn/NmjWCdAAAAAASCdEhT+08A33evHlRXl7e5cdvaGiI9evXR2lpaRQVFXX58WtqamLq1KmpnYkPAAAAQPcgRIc8V15eHhUVFakce/z48akcFwAAAADayoVFAQAAAAAggRAdAAAAAAASCNEBAAAAACCBEB0AAAAAABII0QEAAAAAIIEQHQAAAAAAEvRKuwEAAGCXtWvXxptvvpnKsWtqalr9Ny19+/aN4cOHp9oDAADsJEQHAIAcsXbt2jj66KPTbiOmTp2adguxZs0aQToAADlBiA4AADli5xno8+bNi/Ly8i4/fkNDQ6xfvz5KS0ujqKioy48fseMs+KlTp6Z2Nj4AAPw5IToAAOSY8vLyqKioSOXY48ePT+W4AACQq1xYFAAAAAAAEgjRAQAAAAAggRAdAAAAAAASdLsQ/dZbb43S0tLo06dPnHzyybFixYrE2rlz50ZBQUGrW58+fbqwWwDIH2Y0AOQe8xkA9l23CtHvv//+mDVrVlx33XWxcuXKOP744+OMM86Il19+OXGffv36xcaNG1tuL774Yhd2DAD5wYwGgNxjPgNAdnSrEP3mm2+OmTNnxiWXXBLHHHNM3HHHHVFcXBz33HNP4j4FBQUxcODAltvhhx/ehR0DQH4wowEg95jPAJAd3SZE3759e1RXV8fpp5/esq1Hjx5x+umnx/LlyxP327JlSxx11FExZMiQOO+88+K///u/u6JdAMgbZjQA5B7zGQCyp9uE6K+++mo0NTXt9lPwww8/POrq6va4z4c+9KG455574he/+EXMmzcvmpubY9y4cfG///u/icdpbGyMzZs3t7oBAMm6YkabzwDQPj5DA0D2dJsQvSPGjh0b06ZNi1GjRsXEiRNjwYIFcdhhh8Wdd96ZuE9VVVWUlJS03IYMGdKFHQNAfmjvjDafAaDz+QwNAHvWbUL0/v37R8+ePWPTpk2ttm/atCkGDhzYpsfo3bt3nHDCCfH8888n1syZMyfq6+tbbhs2bNinvgFgf9cVM9p8BoD28RkaALKn24ToBxxwQFRWVsbixYtbtjU3N8fixYtj7NixbXqMpqamePbZZ2PQoEGJNYWFhdGvX79WNwAgWVfMaPMZANrHZ2gAyJ5eaTfQHrNmzYrp06fH6NGj46STTopbbrkltm7dGpdccklEREybNi2OOOKIqKqqioiIr33tazFmzJgYNmxYvPHGG/GNb3wjXnzxxZgxY0aaTwMA9jtmNADkHvMZALKjW4XoF1xwQbzyyitx7bXXRl1dXYwaNSoefPDBlgulvPTSS9Gjx66T6//0pz/FzJkzo66uLg455JCorKyMJ598Mo455pi0ngIA7JfMaADIPeYzAGRHQSaTyaTdRC7bvHlzlJSURH19vV9LY7+ycuXKqKysjOrq6qioqEi7nS6X78+f/Ve+zK18eZ7kH/PJnwH7r3yZXfnyPMlPa9eujTfffDOVY9fU1MTUqVNj3rx5UV5enkoPffv2jeHDh6dybOgsbZ1b3epMdAAAAADoamvXro2jjz467TZi6tSpqR5/zZo1gnTykhAdAAAAAPZi5xnoaZ0J3tDQEOvXr4/S0tIoKirq8uPvPBM+rTPxIW1CdAAAAABog/Ly8tSWGxs/fnwqxwUierx3CQAAAAAA5CchOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAk6JV2AwAAwC4DDyqIojfWRPwxP893KXpjTQw8qCDtNgAAoIUQHQAAcshnKw+I8qWfjViadifpKI8dfwYAAJArhOgAAJBD7qzeHhdcOzfKy8rSbiUVNbW1cedNF8W5aTcCAAD/R4gOAAA5pG5LJhoOPjpi8Ki0W0lFQ11z1G3JpN0GAAC0yM+FFgEAAAAAoA2E6AAAAAAAkECIDgAAAAAACYToAAAAAACQQIgOAAAAAAAJeqXdAAAAAADkuoEHFUTRG2si/ph/56QWvbEmBh5UkHYbkBohOgAAAAC8h89WHhDlSz8bsTTtTrpeeex4/pCvhOgAAAAA8B7urN4eF1w7N8rLytJupcvV1NbGnTddFOem3QikRIgOAAAAAO+hbksmGg4+OmLwqLRb6XINdc1RtyWTdhuQmvxbxAkAAAAAANpIiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACYToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACYToAAAAAACQoNuF6LfeemuUlpZGnz594uSTT44VK1bstf6nP/1plJWVRZ8+fWLEiBHxq1/9qos6BYD8YkYDQO4xnwFg33WrEP3++++PWbNmxXXXXRcrV66M448/Ps4444x4+eWX91j/5JNPxoUXXhif+cxn4umnn47JkyfH5MmTY/Xq1V3cOQDs38xoAMg95jMAZEe3CtFvvvnmmDlzZlxyySVxzDHHxB133BHFxcVxzz337LH+29/+dvzVX/1VfPnLX47y8vK44YYboqKiIr773e92cecAsH8zowEg95jPAJAdvdJuoK22b98e1dXVMWfOnJZtPXr0iNNPPz2WL1++x32WL18es2bNarXtjDPOiIULF7a/ga1bI3r23H17z54Rffq0rkvSo0dEUVHHardti8hk9lxbUBBRXNyx2oaGiObm5D4OPLBjtW+9FdHUlJ3a4uIdfUdENDZGvPNOdmqLinb8OUdEbN8e8fbb2ant02fX35X21L799o76JIWFEb16tb/2nXd2/Fn8mR4NDVG887F2SqhtccABEb177/i6qWnH/7skvXvvqG9vbXPzjr9r2ajt1WvHn0XEjtfEtm0td+18/j0aGna8FvdSu5v2vO69R+y51ntE+2vb87rvYqnOaPPZay+XXnvmc9tq32PmtprRjY3m855qvUfs+Lo7vkd0IZ+hvf4iwuvPjPYZOqnWe8SOr71HJN//5zLdxB/+8IdMRGSefPLJVtu//OUvZ0466aQ97tO7d+/Mvffe22rbrbfemhkwYEDicd56661MfX19y23Dhg2ZiMjU73i57H4766zWD1BcvOe6iExm4sTWtf37J9eOHt269qijkmuPOaZ17THHJNcedVTr2tGjk2v7929dO3Ficm1xcevas85Krv3zv3bnn7/32i1bdtVOn7732pdf3lX7+c/vvXbdul21V16599rVq3fVXnfd3mtXrNhV+/Wv77320Ud31X73u3uvXbRoV+0PfrD32gce2FX7wAN7rV133XW7ahct2vvjfve7u2offXTvtV//+q7aFSv2XvvuHlav3nvtlVfuql23bu+1n//8rtqXX9577fTpu2q3bNl77fnnZ1rZW633iB037xG7bp38HlFfX5+JiEx9fX2mq3TFjDafvfZy/bWXyWTM553M5128R+zgPSKTyWQy9bfdlunKGe0z9FFef5mM199OZvQOZvQu3iN28B7R5s/Q3Wo5l65QVVUVJSUlLbchQ4ak3RIA5D3zGQBykxkNQD4oyGQymbSbaIvt27dHcXFxzJ8/PyZPntyyffr06fHGG2/EL37xi932OfLII2PWrFlx+eWXt2y77rrrYuHChfG73/1uj8dpbGyMxnf9Ks7mzZtjyJAhUf/HP0a/fv1238Gvmey51q+ZtL+2i38VbdWqVfHxv5oQi372wyg/7rgdG5uaIt7ey+P26r3rcZubI7bv5dfWevXaUd/e2kwmonEvv7bWntqevXb96lxkWv063HPPrYmz/vqS+NmDy2LUqFF+FS2p1nvEjq+70XvE5s2bo6SkJOrr6/c8tzpBV8xo8/nPeO21v7Ybzefxp5wSy37zm6g4+eS91rbYj35VPGLXn8ETjz8eo0aPNp/3VOs9YsfX3ew9YvNrr0VJ//5dNqN9hvb6iwivPzM6azO61Xz2GTq51nvEjq+70XtEWz9Dd5s10Q844ICorKyMxYsXt/wDoLm5ORYvXhyXXXbZHvcZO3ZsLF68uNU/AB566KEYO3Zs4nEKCwujcOebwLsdeGDrv5BJ2lLTkdp3vyCzWfvuN5Bs1r77DS+btYWFu96ks1l7wAG7hkpatb17vyvwzWJtr157XOOpuagoPll5QJQ/eWnEk217qP3JhyLik5UHRHNR0e6vxYKCznste4/YwXtE+2vb87rvYl0xo83nLNV67bW/NoX5vG3nY71H7R717Nn2v8Ptqe3Ro3Nq9zBzd/4ZNBcVtf67Yj7v4j1ih+74HtGFfIb2+osIr7+O1JrRO/zZ3G01n32GTuY9Yofu9h7RBt0mRI+ImDVrVkyfPj1Gjx4dJ510Utxyyy2xdevWuOSSSyIiYtq0aXHEEUdEVVVVRER86UtfiokTJ8ZNN90UH/3oR+O+++6Lp556Ku666640nwbkjDurt8cF186N8rKytFvpcjW1tXHnTRfFuWk3AvsJMxoAco/5DADZ0a1C9AsuuCBeeeWVuPbaa6Ouri5GjRoVDz74YBx++OEREfHSSy9Fjx67lnkfN25c3HvvvXHNNdfE1VdfHcOHD4+FCxfGcTuXroA8tm3btqjbkoknXtgSDQfv5deHOklDQ0OsX78+SktLo6g9P33NkpqNTVG3pVusZgXdghkNALnHfAaA7Og2a6KnJY21ZaEr3H333TFz5sy020jdmjVrYvjw4Wm3AVmTL3MrX54n+WflypVRWVkZ1dXVUVFRkXY7qfBnwP4qX2ZXvjxP8k++z6d8f/7sv/a7NdGB7Nq5LmJZWVkUt2d9ryypqamJqVOnxrx586K8vLzLjx8R0bdvXwE6AAAAAHslRIc81b9//5gxY0babUR5ebmfYgPA/9m2bVtE7DjbKw1pL7cWseMH7QAAkEuE6AAAkCNqa2sjIiy5Fjt+YwwAAHKBEB0AAHKE5dZ2sOQaAAC5RIgOAAA5wnJrAJCb8n3JNcutke+E6AAAAACwF5Zc28Fya+QrIToAAAAA7IUl1yy3Rn4TogMAAADAXlhyDfJbj7QbAAAAAACAXCVEBwAAAACABEJ0AAAAAABIIEQHAAAAAIAEQnQAAAAAAEggRAcAAAAAgARCdAAAAAAASCBEBwAAAACABEJ0AAAAAABIIEQHAAAAAIAEQnQAAAAAAEjQK+0GgO5p27ZtUVtb2+H9a2pqWv23o8rKyqK4uHifHgMAAAAAkgjRgQ6pra2NysrKfX6cqVOn7tP+1dXVUVFRsc99AAAAAMCeCNGBDikrK4vq6uoO79/Q0BDr16+P0tLSKCoq2qc+AAAAAKCzCNGBDikuLt7nM8DHjx+fpW4AAAAAoHO4sCgAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAECCXmk3AAAAAAD7s23btkVtbW2H96+pqWn1344qKyuL4uLifXoMyEdCdAAA2E/kygf0CB/SAeDdamtro7Kycp8fZ+rUqfu0f3V1dVRUVOxzH5BvhOgAALCfyJUP6BE+pAPAu5WVlUV1dXWH929oaIj169dHaWlpFBUV7VMfQPsJ0QEAYD+RKx/Qd/YCAOxQXFy8zz9cHj9+fJa6AdpLiA4AAPsJH9ABACD7eqTdAAAAAAAA5CohOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAk6DYh+uuvvx4XX3xx9OvXLw4++OD4zGc+E1u2bNnrPpMmTYqCgoJWt8997nNd1DEA5AczGgByj/kMANnTK+0G2uriiy+OjRs3xkMPPRRvv/12XHLJJfE3f/M3ce+99+51v5kzZ8bXvva1lu+Li4s7u1UAyCtmNADkHvMZALKnW4ToNTU18eCDD8Z//dd/xejRoyMi4jvf+U6cddZZ8c1vfjMGDx6cuG9xcXEMHDiwq1oFgLxiRgNA7jGfASC7ukWIvnz58jj44INbhn9ExOmnnx49evSI3/72t/Gxj30scd8f//jHMW/evBg4cGCcc8458dWvfnWvP0lvbGyMxsbGlu/r6+sjImLz5s1ZeCYA0Ll2zqtMJtMlx+uqGW0+A9DddeWM9hkaANqmrfO5W4TodXV1MWDAgFbbevXqFYceemjU1dUl7nfRRRfFUUcdFYMHD45nnnkm/u7v/i6ee+65WLBgQeI+VVVVcf311++2fciQIR1/AgDQxd58880oKSnp9ON01Yw2nwHYX3TFjPYZGgDa573mc6oh+le+8pX4l3/5l73W1NTUdPjx/+Zv/qbl6xEjRsSgQYPiwx/+cPz+97+PD37wg3vcZ86cOTFr1qyW75ubm+P111+P973vfVFQUNDhXoDWNm/eHEOGDIkNGzZEv3790m4H9huZTCbefPPNvf6adlvk2ow2n6FrmM/QebIxo3NtPkeY0dBVzGjoHG2dz6mG6LNnz45PfepTe635wAc+EAMHDoyXX3651fZ33nknXn/99Xat1XbyySdHRMTzzz+f+A+AwsLCKCwsbLXt4IMPbvMxgPbp16+ffwBAlmXj7LZcm9HmM3Qt8xk6x77O6FybzxFmNHQ1Mxqyry3zOdUQ/bDDDovDDjvsPevGjh0bb7zxRlRXV0dlZWVERDzyyCPR3NzcMtTbYtWqVRERMWjQoA71CwD5wowGgNxjPgNAOnqk3UBblJeXx1/91V/FzJkzY8WKFfHEE0/EZZddFp/4xCdaTrX/wx/+EGVlZbFixYqIiPj9738fN9xwQ1RXV8f69evj//v//r+YNm1anHrqqTFy5Mg0nw4A7DfMaADIPeYzAGRXtwjRI3ZcIbysrCw+/OEPx1lnnRWnnHJK3HXXXS33v/322/Hcc8/Ftm3bIiLigAMOiIcffjg+8pGPRFlZWcyePTs+/vGPx7//+7+n9RSAdyksLIzrrrtut1/9BLofMxr2H+Yz7D/MZ9i/mNGQroJMJpNJuwkAAAAAAMhF3eZMdAAAAAAA6GpCdAAAAAAASCBEBwAAAACABEJ0AAAAAABIIEQHutTSpUvjnHPOicGDB0dBQUEsXLgw7ZYAgDCjASAXmc+QG4ToQJfaunVrHH/88XHrrbem3QoA8C5mNADkHvMZckOvtBsA8suZZ54ZZ555ZtptAAB/xowGgNxjPkNucCY6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJOiVdgNAftmyZUs8//zzLd+vW7cuVq1aFYceemgceeSRKXYGAPnNjAaA3GM+Q24oyGQymbSbAPLHkiVL4rTTTttt+/Tp02Pu3Lld3xAAEBFmNADkIvMZcoMQHQAAAAAAElgTHQAAAAAAEgjRAQAAAAAggRAdAAAAAAASCNEBAAAAACCBEB0AAAAAABII0QEAAAAAIIEQHQAAAAAAEgjRAQAAAAAggRAdAAAAAAASCNEBAAAAACCBEB0AAAAAABII0QEAAAAAIIEQHQAAAAAAEgjRAQAAAAAggRAdAAAAAAASCNEBAAAAACCBEB0AAAAAABII0QEAAAAAIEG3CdGrqqrixBNPjL59+8aAAQNi8uTJ8dxzz+11n7lz50ZBQUGrW58+fbqoYwDID2Y0AOQe8xkAsqfbhOiPPfZYXHrppfGb3/wmHnrooXj77bfjIx/5SGzdunWv+/Xr1y82btzYcnvxxRe7qGMAyA9mNADkHvMZALKnV9oNtNWDDz7Y6vu5c+fGgAEDorq6Ok499dTE/QoKCmLgwIGd3R4A5C0zGgByj/kMANnTbUL0P1dfXx8REYceeuhe67Zs2RJHHXVUNDc3R0VFRdx4441x7LHHJtY3NjZGY2Njy/fNzc3x+uuvx/ve974oKCjITvMA0EkymUy8+eabMXjw4OjRI51fOOuMGW0+A9DdpT2jfYYGgN21dT4XZDKZTBf2lRXNzc1x7rnnxhtvvBGPP/54Yt3y5ctj7dq1MXLkyKivr49vfvObsXTp0vjv//7veP/737/Hff7hH/4hrr/++s5qHQC6xIYNGxJnXWfqrBltPgOwv0hjRvsMDQB7917zuVuG6H/7t38b//Ef/xGPP/54u/7x8fbbb0d5eXlceOGFccMNN+yx5s9/il5fXx9HHnlkbNiwIfr167fPvQNAZ9q8eXMMGTIk3njjjSgpKeny43fWjDafAeju0pzRPkMDwJ61dT53u+VcLrvssli0aFEsXbq03T+97927d5xwwgnx/PPPJ9YUFhZGYWHhbtv79evnHwAAdBtp/Pp0Z85o8xmA/UVXz2ifoQHgvb3XfE5nsdQOyGQycdlll8XPf/7zeOSRR2Lo0KHtfoympqZ49tlnY9CgQZ3QIQDkJzMaAHKP+QwA2dNtzkS/9NJL4957741f/OIX0bdv36irq4uIiJKSkigqKoqIiGnTpsURRxwRVVVVERHxta99LcaMGRPDhg2LN954I77xjW/Eiy++GDNmzEjteQDA/saMBoDcYz4DQPZ0mxD99ttvj4iISZMmtdr+gx/8ID71qU9FRMRLL73U6iqqf/rTn2LmzJlRV1cXhxxySFRWVsaTTz4ZxxxzTFe1DQD7PTMaAHKP+QwA2dMtLyzalTZv3hwlJSVRX19vPTcAcl6+zK18eZ4A7D/yZXbly/MEYP/Q1rnVbdZEBwAAAACAriZEBwAAAACABEJ0AAAAAABIIEQHAAAAAIAEQnQAAAAAAEggRAcAAAAAgARCdAAAAAAASNAr7QYAAID0NTU1xbJly2Ljxo0xaNCgmDBhQvTs2TPttgAAIHXORAcAgDy3YMGCGDZsWJx22mlx0UUXxWmnnRbDhg2LBQsWpN0aAACkTogOAAB5bMGCBXH++efHiBEjYvny5fHmm2/G8uXLY8SIEXH++ecL0gEAyHtCdAAAyFNNTU0xe/bsOPvss2PhwoUxZsyYOOigg2LMmDGxcOHCOPvss+PKK6+MpqamtFsFAIDUCNEBACBPLVu2LNavXx9XX311ZDKZWLJkSfzkJz+JJUuWRCaTiTlz5sS6deti2bJlabcKAACpcWFRAADIUxs3boyIiN///vdx4YUXxvr161vuKy0tjX/8x39sVQcAAPnImegAAJCnBg0aFBERn/zkJ/e4JvonP/nJVnUAAJCPnIkOAAB5aty4cdGrV6943/veFwsWLIhevXZ8PBgzZkwsWLAg3v/+98drr70W48aNS7lTAABIjzPRAQAgTz355JPxzjvvxKZNm2LKlCmtzkSfMmVKbNq0Kd5555148skn024VAABSI0QHAIA8tXOt83nz5sWzzz4b48aNi379+sW4ceNi9erVMW/evFZ1AACQjyznAgAAeWrnWucf/OAH4/nnn49ly5bFxo0bY9CgQTFhwoRYsWJFqzoAAMhHQnQAAMhTEyZMiNLS0rjxxhtj4cKFMWnSpJb7mpubo6qqKoYOHRoTJkxIr0kAAEiZ5VwAACBP9ezZM2666aZYtGhRTJ48udWa6JMnT45FixbFN7/5zejZs2farQIAQGqciQ4AAHlsypQpMX/+/Jg9e3aMGzeuZfvQoUNj/vz5MWXKlBS7AwCA9AnRAQAgz02ZMiXOO++83dZEdwY6AAAI0QEAgNixtMu710QHAAB2sCY6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAECCXmk3AAAAZMe2bduitra2w/s3NDTE+vXro7S0NIqKivapl7KysiguLt6nxwAAIpqammLZsmWxcePGGDRoUEyYMCF69uyZdluQV4ToAACwn6itrY3Kysq024iIiOrq6qioqEi7DQDo1hYsWBCzZ8+O9evXt2wrLS2Nm266KaZMmZJeY5BnhOgAALCfKCsri+rq6g7vX1NTE1OnTo158+ZFeXn5PvcCAHTcggUL4vzzz4+zzz47fvKTn8Rxxx0Xq1evjhtvvDHOP//8mD9/viAduogQHQAA9hPFxcVZOfu7vLzcWeQAkKKmpqaYPXt2nH322bFw4cLo0WPHZQ3HjBkTCxcujMmTJ8eVV14Z5513nqVdoAu4sCgAAAAA5JBly5bF+vXr4+qrr24J0Hfq0aNHzJkzJ9atWxfLli1LqUPIL0J0AAAAAMghGzdujIiI4447bo/379y+sw7oXN0mRK+qqooTTzwx+vbtGwMGDIjJkyfHc8899577/fSnP42ysrLo06dPjBgxIn71q191QbcAkD/MaADIPeYzdG+DBg2KiIjVq1fv8f6d23fWAZ2r24Tojz32WFx66aXxm9/8Jh566KF4++234yMf+Uhs3bo1cZ8nn3wyLrzwwvjMZz4TTz/9dEyePDkmT56c+AYEALSfGQ0Aucd8hu5twoQJUVpaGjfeeGM0Nze3uq+5uTmqqqpi6NChMWHChJQ6hPxSkMlkMmk30RGvvPJKDBgwIB577LE49dRT91hzwQUXxNatW2PRokUt28aMGROjRo2KO+64o03H2bx5c5SUlER9fX3069cvK70DQGfJhbnVFTM6F54n7I9WrlwZlZWVUV1d7cKikGVpzy6foaH7WbBgQZx//vlx9tlnx5w5c+K4446L1atXR1VVVSxatCjmz58fU6ZMSbtN6NbaOre6zZnof66+vj4iIg499NDEmuXLl8fpp5/eatsZZ5wRy5cv79TeACCfmdEAkHvMZ+h+pkyZEvPnz49nn302xo0bF/369Ytx48bF6tWrBejQxXql3UBHNDc3x+WXXx7jx49PvMBCRERdXV0cfvjhrbYdfvjhUVdXl7hPY2NjNDY2tny/efPmfW8YAPJEZ81o8xkAOs5naOi+pkyZEuedd14sW7YsNm7cGIMGDYoJEyZEz549024N8kq3DNEvvfTSWL16dTz++ONZf+yqqqq4/vrrs/64AJAPOmtGm88A0HE+Q0P31rNnz5g0aVLabUBe63bLuVx22WWxaNGiePTRR+P973//XmsHDhwYmzZtarVt06ZNMXDgwMR95syZE/X19S23DRs2ZKVvANjfdeaMNp8BoGN8hgaAfddtQvRMJhOXXXZZ/PznP49HHnkkhg4d+p77jB07NhYvXtxq20MPPRRjx45N3KewsDD69evX6gYAJOuKGW0+A0D7+AwNANnTbZZzufTSS+Pee++NX/ziF9G3b9+WNdlKSkqiqKgoIiKmTZsWRxxxRFRVVUVExJe+9KWYOHFi3HTTTfHRj3407rvvvnjqqafirrvuSu15AMD+xowGgNxjPgNA9nSbM9Fvv/32qK+vj0mTJsWgQYNabvfff39LzUsvvRQbN25s+X7cuHFx7733xl133RXHH398zJ8/PxYuXLjXC6kAAO1jRgNA7jGfASB7CjKZTCbtJnLZ5s2bo6SkJOrr6/1aGgA5L1/mVr48T+hqK1eujMrKyqiuro6Kioq024H9Sr7Mrnx5ngDsH9o6t7rNmegAAAAAANDVhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACYToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACYToAAAAAACQoFfaDQDd07Zt26K2trbD+zc0NMT69eujtLQ0ioqKOvw4ZWVlUVxc3OH9AQAAAGBvhOhAh9TW1kZlZWXabUR1dXVUVFSk3QYAAAAA+ykhOtAhZWVlUV1d3eH9a2pqYurUqTFv3rwoLy/fpz4AAAAAoLMI0YEOKS4uzsoZ4OXl5c4kBwAAACBnubAoAAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAk6JV2AwAAAADAnjU1NcWyZcti48aNMWjQoJgwYUL07Nkz7bYgrzgTHQAAAABy0IIFC2LYsGFx2mmnxUUXXRSnnXZaDBs2LBYsWJB2a5BXhOgAAAAAkGMWLFgQ559/fowYMSKWL18eb775ZixfvjxGjBgR559/viAdupAQHQAAAABySFNTU8yePTvOPvvsWLhwYYwZMyYOOuigGDNmTCxcuDDOPvvsuPLKK6OpqSntViEvCNEBAAAAIIcsW7Ys1q9fH1dffXX06NE6vuvRo0fMmTMn1q1bF8uWLUupQ8gvQnQAAAAAyCEbN26MiIjjjjtuj/fv3L6zDuhcQnQAAAAAyCGDBg2KiIjVq1fv8f6d23fWAZ1LiA4AAAAAOWTChAlRWloaN954Y7z99tuxZMmS+MlPfhJLliyJt99+O6qqqmLo0KExYcKEtFuFvNAr7QYAAAAAgF169uwZN910U5x//vlRUlISDQ0NLfcVFRXFW2+9FfPnz4+ePXum2CXkD2eiAwAAAEAOymQyu20rKCjY43ag8wjRAQAAACCHNDU1xezZs+Occ86J+vr6ePTRR+Pee++NRx99NN54440455xz4sorr4ympqa0W4W8YDkXAAAAAMghy5Yti/Xr18dPfvKT6N27d0yaNKnV/XPmzIlx48bFsmXLdrsPyD5nogMAAABADtm4cWNERBx33HF7vH/n9p11QOcSogMAAABADhk0aFBERKxevXqP9+/cvrMO6FxCdAAAAADIIRMmTIjS0tK48cYbo7m5udV9zc3NUVVVFUOHDo0JEyak1CHkFyE6AAAAAOSQnj17xk033RSLFi2KyZMnx/Lly+PNN9+M5cuXx+TJk2PRokXxzW9+M3r27Jl2q5AXXFgUAAAAAHLMlClTYv78+TF79uwYN25cy/ahQ4fG/PnzY8qUKSl2B/lFiA4AAAAAOWjKlClx3nnnxbJly2Ljxo0xaNCgmDBhgjPQoYsJ0QEAAAAgR/Xs2TMmTZqUdhuQ16yJDgAAAAAACYToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACYToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACdodoq9cuTKeffbZlu9/8YtfxOTJk+Pqq6+O7du3Z7W5P7d06dI455xzYvDgwVFQUBALFy7ca/2SJUuioKBgt1tdXV2n9gkA+cR8BoDcZEYDQHa0O0T/7Gc/G2vWrImIiBdeeCE+8YlPRHFxcfz0pz+Nq666KusNvtvWrVvj+OOPj1tvvbVd+z333HOxcePGltuAAQM6qUMAyD/mMwDkJjMaALKjV3t3WLNmTYwaNSoiIn7605/GqaeeGvfee2888cQT8YlPfCJuueWWLLe4y5lnnhlnnnlmu/cbMGBAHHzwwdlvCAAwnwEgR5nRAJAd7T4TPZPJRHNzc0REPPzww3HWWWdFRMSQIUPi1VdfzW53WTJq1KgYNGhQ/OVf/mU88cQTabcDAIT5DAC5yowGgNbafSb66NGj4x//8R/j9NNPj8ceeyxuv/32iIhYt25dHH744VlvcF8MGjQo7rjjjhg9enQ0NjbG3XffHZMmTYrf/va3UVFRscd9Ghsbo7GxseX7zZs3d1W7AJAXzGcAyE1mNADsWbtD9FtuuSUuuuiiWLhwYfz93/99DBs2LCIi5s+fH+PGjct6g/viQx/6UHzoQx9q+X7cuHHx+9//Pr71rW/Fj370oz3uU1VVFddff31XtQgAecd8BoDcZEYDwJ61ezmXkSNHxurVq6O+vj6uu+66lu3f+MY34t/+7d+y2lxnOOmkk+L5559PvH/OnDlRX1/fctuwYUMXdgcA+cl8BoDcZEYDQAfORL/22mvjtNNOi3HjxkVhYWHL9j59+mS1sc6yatWqGDRoUOL9hYWFrZ4XAND5zGcAyE1mNAB0IERfvnx53HzzzfHOO+/EiSeeGBMnToxJkybF+PHjo6ioqDN6bLFly5ZWPwFft25drFq1Kg499NA48sgjY86cOfGHP/whfvjDH0bEjqVnhg4dGscee2y89dZbcffdd8cjjzwSv/71rzu1TwDIJ+YzAOQmMxoAsqPdIfpDDz0U77zzTvz2t7+NpUuXxmOPPRb/+q//Go2NjXHiiSfG448/3hl9RkTEU089FaeddlrL97NmzYqIiOnTp8fcuXNj48aN8dJLL7Xcv3379pg9e3b84Q9/iOLi4hg5cmQ8/PDDrR4DANg35jMA5CYzGgCyoyCTyWQ6uvOaNWvi0UcfjYcffjgWLlwYJSUl8eqrr2azv9Rt3rw5SkpKor6+Pvr165d2O7DfWLlyZVRWVkZ1dXVUVFSk3Q7sN/JlbuXL84SuZj5D58mX2ZUvzxOA/UNb51a7Lyx61113xUUXXRRHHHFEjBs3Lh588ME45ZRT4qmnnopXXnlln5oGAAAAAIBc0u7lXD73uc/FYYcdFrNnz47Pf/7zcdBBB3VGXwAAAAAAkLp2n4m+YMGCuPjii+O+++6Lww47LMaNGxdXX311/PrXv45t27Z1Ro8AAAAAAJCKdp+JPnny5Jg8eXJERNTX18eyZcvipz/9aZx99tnRo0ePeOutt7LdIwAAAAB0W9u2bYva2toO79/Q0BDr16+P0tLSKCoq6vDjlJWVRXFxcYf3h3zV7hA9IuK1116Lxx57LJYsWRJLliyJ//7v/45DDjkkJkyYkO3+AAAAAKBbq62tjcrKyrTbcPFw6KB2h+gjRoyImpqaOOSQQ+LUU0+NmTNnxsSJE2PkyJGd0R8AAAAAdGtlZWVRXV3d4f1rampi6tSpMW/evCgvL9+nPoD269CFRSdOnBjHHXdcZ/QDAAAAAPuV4uLirJwBXl5e7kxySEG7Q/RLL7205etMJhMREQUFBdnrCAAAAAAAckSPjuz0wx/+MEaMGBFFRUVRVFQUI0eOjB/96EfZ7g0AAAAAAFLV7jPRb7755vjqV78al112WYwfPz4iIh5//PH43Oc+F6+++mpcccUVWW8SAAAAAADS0O4Q/Tvf+U7cfvvtMW3atJZt5557bhx77LHxD//wD0J0AAAAAAD2G+1ezmXjxo0xbty43baPGzcuNm7cmJWmAAAAAAAgF7Q7RB82bFg88MADu22///77Y/jw4VlpCgAAAAAAckG7l3O5/vrr44ILLoilS5e2rIn+xBNPxOLFi/cYrgMAAAAAQHfV7jPRP/7xj8eKFSuif//+sXDhwli4cGH0798/VqxYER/72Mc6o0cAAAAAAEhFu85Ef/vtt+Ozn/1sfPWrX4158+Z1Vk8AAAAAAJAT2nUmeu/eveNnP/tZZ/UCAAAAAAA5pd3LuUyePDkWLlzYCa0AAAAAAEBuafeFRYcPHx5f+9rX4oknnojKyso48MADW93/xS9+MWvNAQAAAABAmtodon//+9+Pgw8+OKqrq6O6urrVfQUFBUJ0AAAAAAD2G+0O0detW9cZfQAAAAAAQM5p95roAAAAAACQL4ToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAl6taXomWeeafMDjhw5ssPNAAAAAABALmlTiD5q1KgoKCiITCYTBQUFe61tamrKSmMAAAAAAJC2Ni3nsm7dunjhhRdi3bp18bOf/SyGDh0at912Wzz99NPx9NNPx2233RYf/OAH42c/+1ln9wsAAAAAAF2mTWeiH3XUUS1f/7//9//iX//1X+Oss85q2TZy5MgYMmRIfPWrX43JkydnvUkAAAAAAEhDuy8s+uyzz8bQoUN32z506ND4n//5n6w0BQAAAAAAuaDdIXp5eXlUVVXF9u3bW7Zt3749qqqqory8PKvNAQAAAABAmtq0nMu73XHHHXHOOefE+9///hg5cmRERDzzzDNRUFAQ//7v/571BgEAAAAAIC3tDtFPOumkeOGFF+LHP/5x1NbWRkTEBRdcEBdddFEceOCBWW8QAAAAAADS0u4QPSLiwAMPjL/5m7/Jdi8AAAAAAJBT2r0mekTEj370ozjllFNi8ODB8eKLL0ZExLe+9a34xS9+kdXmAAAAAAAgTe0O0W+//faYNWtWnHnmmfGnP/0pmpqaIiLikEMOiVtuuSXb/QEAAAAAQGraHaJ/5zvfie9973vx93//99Gr167VYEaPHh3PPvtsVpsDAAAAAIA0tTtEX7duXZxwwgm7bS8sLIytW7dmpSkAAAAAAMgF7Q7Rhw4dGqtWrdpt+4MPPhjl5eXZ6AkAAAAAAHJCr/cuaW3WrFlx6aWXxltvvRWZTCZWrFgRP/nJT6KqqiruvvvuzugRAAAAAABS0e4QfcaMGVFUVBTXXHNNbNu2LS666KIYPHhwfPvb345PfOITndEjAAAAAACkot0hekTExRdfHBdffHFs27YttmzZEgMGDMh2XwAAAAAAkLoOheg7FRcXR3FxcbZ6AQAAAACAnNKmEP2EE06IgoKCNj3gypUr96khAAAAAADIFW0K0SdPntzJbQAAAAAAQO5pU4h+3XXXdXYfAAAAAACQc3qk3QAAAAAAAOSqNp2Jfsghh7R5TfTXX399nxoCAAAAAIBc0aYQ/ZZbbunkNgAAAAAAIPe0KUSfPn16Z/cBAAAAAAA5p00h+ubNm6Nfv34tX+/NzjoAAAAAAOju2hSiH3zwwVFXVxcDBgyIgw8+eI/ro2cymSgoKIimpqasNwkAAAAAAGloU4j+6KOPxqGHHtryNQAAAAAA5IM2hejf/va344QTToh+/frFiy++GBdccEEUFhZ2dm8AAAAAAJCqHm0pWrRoUWzdujUiIi655JKor6/v1KYAAAAAACAXtOlM9LKyspgzZ06cdtppkclk4oEHHki8gOi0adOy2iAAAAAAAKSlTSH6HXfcEbNmzYpf/vKXUVBQENdcc80eLy5aUFAgRAcAAAAAYL/RphB93Lhx8Zvf/CYiInr06BFr1qyJAQMGdGpjAAAAAACQtjatif5u69ati8MOO6wzegEAAAAAgJzSpjPR3+2oo47qjD4AAAAAACDntPtM9DQtXbo0zjnnnBg8eHAUFBTEwoUL33OfJUuWREVFRRQWFsawYcNi7ty5nd4nAOQT8xkAcpMZDQDZ0a1C9K1bt8bxxx8ft956a5vq161bFx/96EfjtNNOi1WrVsXll18eM2bMiP/8z//s5E4BIH+YzwCQm8xoAMiONi/nsm3btiguLu7MXt7TmWeeGWeeeWab6++4444YOnRo3HTTTRERUV5eHo8//nh861vfijPOOKOz2gSAvGI+A0BuMqMBIDvafCZ6//794+yzz4677ror6urqOrOnrFm+fHmcfvrprbadccYZsXz58pQ6AgDMZwDITWY0AOxZm0P02traOOOMM+KBBx6I0tLSOPnkk+Of/umf4tlnn+3M/vZJXV1dHH744a22HX744bF58+ZoaGjY4z6NjY2xefPmVjcAIHvMZwDITWY0AOxZm0P0I488Mr7whS/Eww8/HJs2bYrLL788nn322ZgwYUJ84AMfiMsvvzweeeSRaGpq6sx+O11VVVWUlJS03IYMGZJ2SwCQ98xnAMhNZjQA+aBDFxYtKSmJCy+8MO6777545ZVX4s4774ympqa45JJL4rDDDosf//jH2e6zQwYOHBibNm1qtW3Tpk3Rr1+/KCoq2uM+c+bMifr6+pbbhg0buqJVAMgb5jMA5CYzGgD2rM0XFk3Su3fv+Mu//Mv4y7/8y/jOd74TTz/9dLzzzjvZ6G2fjR07Nn71q1+12vbQQw/F2LFjE/cpLCyMwsLCzm4NAPKW+QwAucmMBoA9a/eZ6Keeempce+21sXjx4njrrbd2u/+EE06IE088MSvN/bktW7bEqlWrYtWqVRERsW7duli1alW89NJLEbHjJ+DTpk1rqf/c5z4XL7zwQlx11VVRW1sbt912WzzwwANxxRVXdEp/AJCPzGcAyE1mNABkR7tD9I985CPxm9/8Js4777w4+OCD45RTTolrrrkmHnroodi2bVtn9NjiqaeeihNOOCFOOOGEiIiYNWtWnHDCCXHttddGRMTGjRtb/jEQETF06ND45S9/GQ899FAcf/zxcdNNN8Xdd98dZ5xxRqf2CQD5xHwGgNxkRgNAdhRkMplMR3Z855134r/+67/iscceiyVLlsQjjzwSPXr02OPZ6d3Z5s2bo6SkJOrr66Nfv35ptwP7jZUrV0ZlZWVUV1dHRUVF2u3AfiNf5la+PE/oauYzdJ58mV358jyhq5nR0DnaOrc6vCb6Cy+8EM8++2z87ne/i2eeeSb69u0bp556akcfDgAAAAAAck67Q/SLLrooHnvssWhsbIxTTz01Jk6cGF/5yldi5MiRUVBQ0Bk9AgAAAABAKtodot93333Rv3//mDFjRvzFX/xFnHLKKVFcXNwZvQEAAAAAQKrafWHR1157Le6+++7Yvn17zJkzJ/r37x/jxo2Lq6++On796193Ro8AAAAAAJCKdofohxxySJx77rlx8803R3V1dTzzzDNx9NFHxze+8Y0488wzO6NHAAAAAABIRbuXc3nttdfiscceiyVLlsSSJUvif/7nf+Lggw+Oc845JyZOnNgZPQIAQN5Yu3ZtvPnmm6kcu6amptV/09K3b98YPnx4qj0AAMBO7Q7RBwwYEP37948JEybEzJkzY9KkSTFixIjO6A0AAPLK2rVr4+ijj067jZg6dWraLcSaNWsE6QAA5IR2h+jPPPNMHHvssZ3RCwAA5LWdZ6DPmzcvysvLu/z4DQ0NsX79+igtLY2ioqIuP37EjrPgp06dmtrZ+AAA8OfaHaIL0AEAoHOVl5dHRUVFKsceP358KscFAIBc1e4LiwIAAAAAQL4QogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAgg6F6I899licc845MWzYsBg2bFice+65sWzZsmz3BgAAAAAAqWp3iD5v3rw4/fTTo7i4OL74xS/GF7/4xSgqKooPf/jDce+993ZGjwAAAAAAkIpe7d3hn/7pn+LrX/96XHHFFS3bvvjFL8bNN98cN9xwQ1x00UVZbRAAAAAAANLS7jPRX3jhhTjnnHN2237uuefGunXrstIUAAAAAADkgnaH6EOGDInFixfvtv3hhx+OIUOGZKUpAAAAAADIBe1ezmX27NnxxS9+MVatWhXjxo2LiIgnnngi5s6dG9/+9rez3iAAAAAAAKSl3SH63/7t38bAgQPjpptuigceeCAiIsrLy+P++++P8847L+sNAgAAAABAWtodokdEfOxjH4uPfexju23PZDJRUFCwz00BAAAAAEAuaPea6J/61Kdi69atu21fv359nHrqqVlpCgAAAAAAckG7Q/Tf/e53MXLkyFi+fHnLtn/7t3+L448/Pvr375/V5gAAAAAAIE3tXs5lxYoVcfXVV8ekSZNi9uzZ8fzzz8d//Md/xM033xwzZ87sjB6BTrJ27dp48803Uzl2TU1Nq/+moW/fvjF8+PDUjg8AAABA7mt3iN67d+/4xje+EcXFxXHDDTdEr1694rHHHouxY8d2Rn9AJ1m7dm0cffTRabcRU6dOTfX4a9asEaQDAAAAkKjdIfrbb78dX/nKV+LWW2+NOXPmxOOPPx5TpkyJ73//+3HWWWd1Ro9AJ9h5Bvq8efOivLy8y4/f0NAQ69evj9LS0igqKury49fU1MTUqVNTOxMfAAAAgO6h3SH66NGjY9u2bbFkyZIYM2ZMZDKZ+PrXvx5TpkyJT3/603Hbbbd1Rp9AJykvL4+KiopUjj1+/PhUjgsAAAAAbdXuC4uOHj06Vq1aFWPGjImIiIKCgvi7v/u7WL58eSxdujTrDQIAAAAAQFrafSb697///T1uP+GEE6K6unqfGwIAAAAAgFzR7jPRIyJ+9KMfxfjx42Pw4MHx4osvRkTELbfcEg8++GBWmwMAAAAAgDS1O0S//fbbY9asWXHWWWfFG2+8EU1NTRERcfDBB8ctt9yS7f4AAAAAACA17Q7Rv/Od78T3vve9+Pu///vo2bNny/bRo0fHs88+m9XmAAAAAAAgTe0O0detWxcnnHDCbtsLCwtj69atWWkKAAAAAAByQbtD9KFDh8aqVat22/7ggw9GeXl5NnoCAAAAAICc0Ku9O8yaNSsuvfTSeOuttyKTycSKFSviJz/5SVRVVcXdd9/dGT0CAAAAAEAq2h2iz5gxI4qKiuKaa66Jbdu2xUUXXRSDBw+Ob3/72/GJT3yiM3oEAAAAAIBUtDtEj4i4+OKL4+KLL45t27bFli1bYsCAAbvVPPHEEzF69OgoLCzc5yYBAAAAACAN7V4T/d2Ki4v3GKBHRJx55pnxhz/8YV8eHgAAAAAAUrVPIfreZDKZznpoAAAAAADoEp0WogMAAAAAQHcnRAcAAAAAgARCdAAAAAAASNBpIXpBQUFnPTQAAAAAAHQJFxYFAAAAAIAEvTq648svvxzPPfdcRER86EMfigEDBrS6/80339y3zgAAAAAAIGXtPhP9zTffjE9+8pNxxBFHxMSJE2PixIlxxBFHxNSpU6O+vr4zegQAAAAAgFS0+0z0GTNmxNNPPx2LFi2KsWPHRkTE8uXL40tf+lJ89rOfjfvuuy/rTQIAAABAmtauXZvaygs1NTWt/puGvn37xvDhw1M7PqSp3SH6okWL4j//8z/jlFNOadl2xhlnxPe+9734q7/6q6w2BwAAAABpW7t2bRx99NFptxFTp05N9fhr1qwRpJOX2h2iv+9974uSkpLdtpeUlMQhhxySlaYAAAAAIFfsPAN93rx5UV5e3uXHb2hoiPXr10dpaWkUFRV1+fFrampi6tSproFI3mp3iH7NNdfErFmz4kc/+lEMHDgwIiLq6uriy1/+cnz1q1/NeoMAAAAAkAvKy8ujoqIilWOPHz8+leMCHQjRb7/99nj++efjyCOPjCOPPDIiIl566aUoLCyMV155Je68886W2pUrV2avUwAAAAAA6GLtDtEnT57cCW0AAAAAAEDuaXeIft1113VGHwAAAAAAkHN6pN0AAAAAAADkqjadiX7ooYfGmjVron///nHIIYdEQUFBYu3rr7+eteYAAAAAACBNbQrRv/Wtb0Xfvn0jIuKWW27pzH4AAAAAACBntClEnz59+h6/BgAAAACA/Vm7LywaEdHc3BzPP/98vPzyy9Hc3NzqvlNPPTUrjQEAAAAAQNraHaL/5je/iYsuuihefPHFyGQyre4rKCiIpqamrDUHAAAAAABpaneI/rnPfS5Gjx4dv/zlL2PQoEF7vcgoAAAAAAB0Z+0O0deuXRvz58+PYcOGdUY/AAAAAACQM3q0d4eTTz45nn/++c7oBQAAAAAAckqbQvRnnnmm5faFL3whZs+eHXPnzo3q6upW9z3zzDOd3W/ceuutUVpaGn369ImTTz45VqxYkVg7d+7cKCgoaHXr06dPp/cIAPnIjAaA3GM+A8C+a9NyLqNGjYqCgoJWFxL99Kc/3fL1zvs6+8Ki999/f8yaNSvuuOOOOPnkk+OWW26JM844I5577rkYMGDAHvfp169fPPfcc616BQCyy4wGgNxjPgNAdrQpRF+3bl1n99EmN998c8ycOTMuueSSiIi444474pe//GXcc8898ZWvfGWP+xQUFMTAgQO7sk0AyDtmNADkHvMZALKjTSH6UUcd1dl9vKft27dHdXV1zJkzp2Vbjx494vTTT4/ly5cn7rdly5Y46qijorm5OSoqKuLGG2+MY489NrG+sbExGhsbW77fvHlzdp4AAOynumJGm88A0D4+QwNA9rT7wqJVVVVxzz337Lb9nnvuiX/5l3/JSlN78uqrr0ZTU1McfvjhrbYffvjhUVdXt8d9PvShD8U999wTv/jFL2LevHnR3Nwc48aNi//93/9NPE5VVVWUlJS03IYMGZLV5wEA+5uumNHmMwC0j8/QAJA97Q7R77zzzigrK9tt+7HHHht33HFHVprKlrFjx8a0adNi1KhRMXHixFiwYEEcdthhceeddybuM2fOnKivr2+5bdiwoQs7BoD80N4ZbT4DQOfzGRoA9qxNy7m8W11dXQwaNGi37Ycddlhs3LgxK03tSf/+/aNnz56xadOmVts3bdrU5vXaevfuHSeccEI8//zziTWFhYVRWFi4T70CQD7pihltPgNA+/gMDQDZ0+4z0YcMGRJPPPHEbtufeOKJGDx4cFaa2pMDDjggKisrY/HixS3bmpubY/HixTF27Ng2PUZTU1M8++yze/whAADQMWY0AOQe8xkAsqfdZ6LPnDkzLr/88nj77bfjL/7iLyIiYvHixXHVVVfF7Nmzs97gu82aNSumT58eo0ePjpNOOiluueWW2Lp1a8uVxqdNmxZHHHFEVFVVRUTE1772tRgzZkwMGzYs3njjjfjGN74RL774YsyYMaNT+wSAfGNGA0DuMZ8BIDvaHaJ/+ctfjtdeey0+//nPx/bt2yMiok+fPvF3f/d3ra763RkuuOCCeOWVV+Laa6+Nurq6GDVqVDz44IMtF0p56aWXokePXSfX/+lPf4qZM2dGXV1dHHLIIVFZWRlPPvlkHHPMMZ3aJwDkGzMaAHKP+QwA2VGQyWQyHdlxy5YtUVNTE0VFRTF8+PD9dg20zZs3R0lJSdTX10e/fv3SbgeyZuXKlVFZWRnV1dVRUVGRdjtdLt+fP/uvfJlb+fI8yT/mkz8D9l/5Mrvy5XmSf/J9PuX782f/1da51e4z0Xc66KCD4sQTT+zo7gAAAAAAkPM6HKIDAADZN/Cggih6Y03EH3u8d/F+qOiNNTHwoIK02wAAgBZCdAAAyCGfrTwgypd+NmJp2p2kozx2/BkAAECuEKIDAEAOubN6e1xw7dwoLytLu5VU1NTWxp03XRTnpt0IAAD8HyE6AADkkLotmWg4+OiIwaPSbiUVDXXNUbclk3YbAADQIj8XWgQAAAAAgDYQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAk6JV2AwAAAACQ6wYeVBBFb6yJ+GP+nZNa9MaaGHhQQdptQGqE6AAAAADwHj5beUCUL/1sxNK0O+l65bHj+UO+EqIDAAAAwHu4s3p7XHDt3CgvK0u7lS5XU1sbd950UZybdiOQEiE6AAAAALyHui2ZaDj46IjBo9Jupcs11DVH3ZZM2m1AavJvEScAAAAAAGgjIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAAiE6AAAAAAAkEKIDAAAAAEACIToAAAAAACQQogMAAAAAQAIhOgAAAAAAJBCiAwAAAABAgl5pNwCkZ+BBBVH0xpqIP+bfz9OK3lgTAw8qSLsNAAAAAHKcEB3y2GcrD4jypZ+NWJp2J12vPHY8fwAAAADYGyE65LE7q7fHBdfOjfKysrRb6XI1tbVx500XxblpNwIAAABAThOiQx6r25KJhoOPjhg8Ku1WulxDXXPUbcmk3QYAAAAAOS7/FkIGAAAAAIA2ciY6AADkiG3btkVExMqVK1M5fkNDQ6xfvz5KS0ujqKgolR5qampSOS4AACQRogMAQI6ora2NiIiZM2em3En6+vbtm3YLAAAQEUJ0AADIGZMnT46IiLKysiguLu7y49fU1MTUqVNj3rx5UV5e3uXH36lv374xfPjw1I4PAADvJkQHAIAc0b9//5gxY0babUR5eXlUVFSk3QYAAOQEFxYFAAAAAIAEQnQAAAAAAEggRAcAAAAAgARCdAAAAAAASODCogAAAACwF9u2bYuIiJUrV6Zy/IaGhli/fn2UlpZGUVFRlx+/pqamy48JuUSIDgAAAAB7UVtbGxERM2fOTLmTdPXt2zftFiAVQnQAAAAA2IvJkydHRERZWVkUFxd3+fFrampi6tSpMW/evCgvL+/y40fsCNCHDx+eyrEhbUJ0AAAAANiL/v37x4wZM9JuI8rLy6OioiLtNiDvuLAoAAAAAAAk6HYh+q233hqlpaXRp0+fOPnkk2PFihV7rf/pT38aZWVl0adPnxgxYkT86le/6qJOASC/mNEAkHvMZwDYd90qRL///vtj1qxZcd1118XKlSvj+OOPjzPOOCNefvnlPdY/+eSTceGFF8ZnPvOZePrpp2Py5MkxefLkWL16dRd3DgD7NzMaAHKP+QwA2VGQyWQyaTfRVieffHKceOKJ8d3vfjciIpqbm2PIkCHxhS98Ib7yla/sVn/BBRfE1q1bY9GiRS3bxowZE6NGjYo77rijTcfcvHlzlJSURP0f/xj9+vXbvaBnz4g+fXZ9v3Vr8oP16BFRVNSx2m3bIpL+VxUURLz7ohbtqW1oiGhuTu7jwAM7VvvWWxFNTdmpLS7e0XdERGNjxDvvZKe2qGjHn3NExPbtEW+/nZ3aPn12/L1ob+3bb++oT1JYGNGrV/tr33lnx5/Fn1m1alWMP+WUWPab30TFySfvtbbFAQdE9O694+umph3/75L07r2jvr21zc07/q5lo7ZXrx1/FhE7XhPbtrXctfP5P/H44zFq1Ki91u6mPa977xF7rvUe0f7aNr7uW+ZWff2e51Yn6eoZbT577bW7tpvM5xbvnrldOJ9bzccTT+zy+bxPtebzLt4j2l/bBe8Rm197LUr69+/SGe0ztNef158ZbUYn1HqP2PG194i2f4bOdBONjY2Znj17Zn7+85+32j5t2rTMueeeu8d9hgwZkvnWt77Vatu1116bGTlyZOJx3nrrrUx9fX3LbcOGDZmIyNTveLnsfjvrrNYPUFy857qITGbixNa1/fsn144e3br2qKOSa485pnXtMcck1x51VOva0aOTa/v3b107cWJybXFx69qzzkqu/fO/duefv/faLVt21U6fvvfal1/eVfv5z++9dt26XbVXXrn32tWrd9Ved93ea1es2FX79a/vvfbRR3fVfve7e69dtGhX7Q9+sPfaBx7YVfvAA3utXXfddbtqFy3a++N+97u7ah99dO+1X//6rtoVK/Ze++4eVq/ee+2VV+6qXbdu77Wf//yu2pdf3nvt9Om7ards2Xvt+ednWtlbrfeIHTfvEbtunfweUV9fn4mITH19faardMWMNp+99nL9tZfJZLI6nzM/+MGuWvN5B/N5F+8RO3Sz94j6227LdOWM9hn6KK+/TMbrbyczegczehfvETt4j2jzZ+hus5zLq6++Gk1NTXH44Ye32n744YdHXV3dHvepq6trV31ERFVVVZSUlLTchgwZsu/NA8B+rCtmtPkMAO3jMzQAZE+3Wc7lj3/8YxxxxBHx5JNPxtixY1u2X3XVVfHYY4/Fb3/72932OeCAA+Lf/u3f4sILL2zZdtttt8X1118fmzZt2uNxGhsbo/Fdv4qzefPmGDJkiF9Fa2+tXzNpf63lXHZ8bTmXjtV6j9jxtfeIVJZz6YoZbT7/Ga+99td2k/ncwq+Kt7/WfN7Fe0T7a/fD5Vx8hvb6iwivPzPajE6q9R6x42vvEW3+DN0r+ZFyS//+/aNnz567De5NmzbFwIED97jPwIED21UfEVFYWBiFO98E3u3AA1v/hUzSlpqO1L77BZnN2ne/gWSz9t1veNmsLSzc9SadzdoDDtg1VNKq7d1713DNZm2vXrv+MfAuzUVFsW3nY71H7R717Nn2v8Ptqe3Ro3NqCwpa1e58/s1FRbs/xp/VvqdcqPUesYP3iFR0xYw2n7NU67XX/touns/7XLuP87nVfHz3n1EXzees1UbkRq33iB28R+yq7UI+Q3v9RYTXX0dqzegdzOiO1XqP2KG7vUe0QbdZzuWAAw6IysrKWLx4ccu25ubmWLx4caufqr/b2LFjW9VHRDz00EOJ9QBA+5nRAJB7zGcAyJ5ucyZ6RMSsWbNi+vTpMXr06DjppJPilltuia1bt8Yll1wSERHTpk2LI444IqqqqiIi4ktf+lJMnDgxbrrppvjoRz8a9913Xzz11FNx1113pfk0ICds+79ftVq5cmUqx29oaIj169dHaWlpFLXnp69ZUlNT0+XHhP2ZGQ0Aucd8BoDs6FYh+gUXXBCvvPJKXHvttVFXVxejRo2KBx98sOXCJy+99FL06LHr5Ppx48bFvffeG9dcc01cffXVMXz48Fi4cGEcd9xxaT0FyBm1tbURETFz5syUO0lX3759024B9gtmNADkHvMZALKj21xYNC1pXKANusKrr74aCxcujLKysihuz/peWVJTUxNTp06NefPmRXl5eZcfP2JHgD58+PBUjg2dJV/mVr48T+hqK1eujMrKyqiuro6Kioq024H9Sr7Mrnx5ntDVzGjoHPvdhUWB7Orfv3/MmDEj7TaivLzcPwAAAAAAyFnd5sKiAAAAAADQ1YToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACYToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACYToAAAAAACQQIgOAAAAAAAJhOgAAAAAAJBAiA4AAAAAAAmE6AAAAAAAkECIDgAAAAAACXql3QDQPW3bti1qa2s7vH9NTU2r/3ZUWVlZFBcX79NjAAAAAEASITrQIbW1tVFZWbnPjzN16tR92r+6ujoqKir2uQ8AAAAA2BMhOtAhZWVlUV1d3eH9GxoaYv369VFaWhpFRUX71AcAAAAAdBYhOtAhxcXF+3wG+Pjx47PUDQAAAAB0DhcWBQAAAACABEJ0AAAAAABIIEQHAAAA+P/bu/egqM77j+OfVSqyckdEqReoiYAVaQRjFQ1kTEQZHZs0ZsRLSaRGkkmMuWhkvEsjJI1ODWkmrTZKLdpEx9pGExsViZEY1LXYqQN2oKHalBRrMNwUuZzfH/mxdcWjKLcV3q8Zx92zz/Oc7+4/n+XL4TkAAJhgT3QAAACgi6ipqVFhYeEdzy8oKHD4vzVCQ0NltVpbvQ4AAADQ2WiiAwAAAF1EYWGhIiMjW73OnDlzWr2GzWZr9U3IAQAAAGdAEx0AAADoIkJDQ2Wz2e54/uXLl1VSUqKgoCC5ubm1uhYAAACgK6CJDgAAAHQRVqu11Vd/R0dHt1E1AAAAQNfAjUUBAAAAAAAAADBBEx0AAAAAAAAAABM00QEAAAAAAAAAMEETHQAAAAAAAAAAEzTRAQAAAAAAAAAwQRMdAAAAAAAAAAATNNEBAAAAAAAAADBBEx0AAAAAAAAAABMunV0AAAAAAAAA0JXV1NSosLDwjucXFBQ4/H+nQkNDZbVaW7UG0B3RRAcAAAAAAADaUWFhoSIjI1u9zpw5c1o132azadSoUa2uA+huaKIDAAAAAAAA7Sg0NFQ2m+2O51++fFklJSUKCgqSm5tbq+oAcPtoogMAAAAAAADtyGq1tvoK8Ojo6DaqBsDt4saiAAAAAAAAAACYoIkOAAAAAAAAAIAJmugAAAAAAAAAAJigiQ4AAAAAAAAAgAma6AAAAAAAAAAAmKCJDgAAAAAAAACACZroAAAAAAAAAACYoIkOAAAAAAAAAIAJmugAAAAAAAAAAJigiQ4AAAAAAAAAgAma6AAAAAAAAAAAmKCJDgAAAAAAAACACZroAAAAAAAAAACYoIkOAAAAAAAAAIAJmugAAAAAAAAAAJigiQ4AAAAAAAAAgAma6AAAAAAAAAAAmKCJDgAAAAAAAACAibumif71119r9uzZ8vT0lLe3t5KSklRVVXXTObGxsbJYLA7/kpOTO6hiAAC6BzIaAADnQz4DANB2XDq7gJaaPXu2SktLdeDAAdXV1enJJ5/UU089pe3bt9903vz587V27Vr7c6vV2t6lAgDQrZDRAAA4H/IZAIC2c1c00QsKCrR//36dOHFCUVFRkqSMjAzFx8frjTfeUGBgoOlcq9Wq/v37d1SpAAB0K2Q0AADOh3wGAKBt3RXbuRw7dkze3t728Jekhx56SD169FBeXt5N52ZlZalv374aMWKEUlJSVFNT097lAgDQbZDRAAA4H/IZAIC2dVdcif7VV1+pX79+DsdcXFzk6+urr776ynTerFmzNGTIEAUGBuqvf/2rXnnlFZ09e1a7d+82nVNbW6va2lr782+++UaSVFFR0cp3AQBA+2vKK8MwOuR8HZXR5DMA4G7XkRnNz9AAALRMS/O5U5voS5cu1WuvvXbTMQUFBXe8/lNPPWV/HB4ergEDBmjixIkqLi7W0KFDbzgnLS1Na9asaXZ80KBBd1wHAAAdrbKyUl5eXnc839kymnwGAHQVrcloZ8tniYwGAHQNt8pni9FRl6rdwIULF3Tx4sWbjvne976n3/3ud3rppZdUXl5uP15fX6/evXtr586deuSRR1p0vurqarm7u2v//v2Ki4u74Zjrf4ve2Nior7/+Wn5+frJYLC06D4Bbq6io0KBBg3T+/Hl5enp2djlAl2EYhiorKxUYGKgePe581zZny2jyGegY5DPQftoio50tnyUyGugoZDTQPlqaz516Jbq/v7/8/f1vOW7s2LG6dOmSbDabIiMjJUnZ2dlqbGzUmDFjWny+/Px8SdKAAQNMx7i6usrV1dXhmLe3d4vPAeD2eHp68gUAaGOtuQK9ibNlNPkMdCzyGWgfrc1oZ8tniYwGOhoZDbS9luTzXXFj0bCwME2ePFnz58/X8ePHlZubq2effVYzZ86031X8yy+/VGhoqI4fPy5JKi4uVmpqqmw2m0pKSvSnP/1JP/nJT/TAAw9o5MiRnfl2AADoMshoAACcD/kMAEDbuiua6NK3dwgPDQ3VxIkTFR8fr/Hjx+vXv/61/fW6ujqdPXvWfufwXr166eDBg5o0aZJCQ0P10ksv6cc//rE++OCDznoLAAB0SWQ0AADOh3wGAKDtdOqe6AC6r9raWqWlpSklJaXZn38CAIDOQT4DAOCcyGigc9FEBwAAAAAAAADAxF2znQsAAAAAAAAAAB2NJjoAAAAAAAAAACZoogMAAAAAAAAAYIImOoAOdeTIEU2bNk2BgYGyWCzas2dPZ5cEAABERgMA4IzIZ8A50EQH0KGqq6sVERGhX/7yl51dCgAAuAYZDQCA8yGfAefg0tkFAOhepkyZoilTpnR2GQAA4DpkNAAAzod8BpwDV6IDAAAAAAAAAGCCJjoAAAAAAAAAACZoogMAAAAAAAAAYIImOgAAAAAAAAAAJmiiAwAAAAAAAABgwqWzCwDQvVRVVamoqMj+/IsvvlB+fr58fX01ePDgTqwMAIDujYwGAMD5kM+Ac7AYhmF0dhEAuo+cnBw9+OCDzY4nJiZq69atHV8QAACQREYDAOCMyGfAOdBEBwAAAAAAAADABHuiAwAAAAAAAABggiY6AAAAAAAAAAAmaKIDAAAAAAAAAGCCJjoAAAAAAAAAACZoogMAAAAAAAAAYIImOgAAAAAAAAAAJmiiAwAAAAAAAABggiY6AAAAAAAAAAAmaKIDaFdPPPGEfvSjH3V2GQAAOLXY2FgtWrSos8sAAKBbc8Y8zsnJkcVi0aVLlzq7FKBbc+nsAgB0bRs3bpRhGJ1dBgAAAAAAd51x48aptLRUXl5enV0K0K3RRAfQrgh6AAC6t7q6On3nO9/p7DIAAHAqhmGooaFBLi43b8316tVL/fv376CqAJhhOxcADmJjY/Xcc89p0aJF8vHxUUBAgDZt2qTq6mo9+eST8vDw0D333KOPPvrIPufMmTOaOnWqPD095eHhoQkTJqi4uFhS8+1cdu3apfDwcLm5ucnPz08PPfSQqqurJUknTpzQww8/rL59+8rLy0sxMTE6deqUQ30bNmxQeHi4+vTpo0GDBumZZ55RVVWVw5jc3FzFxsbKarXKx8dHcXFxKi8vb6dPDACAtrdv3z55eXkpKytL58+f1+OPPy5vb2/5+vpq+vTpKikpsY9tytp169YpICBA3t7eWrt2rerr67V48WL5+vpq4MCB2rJli31OSUmJLBaL3n//fU2YMEFubm4aPXq0/v73v+vEiROKioqSu7u7pkyZogsXLjjUtnnzZoWFhal3794KDQ3V22+/3Wzd9957TzExMerdu7eysrJaPG/37t168MEHZbVaFRERoWPHjrXTJwwAwI01NjZqyZIl8vX1Vf/+/bV69WpJ/8uq/Px8+9hLly7JYrEoJyfnlus2bcvy0UcfKTIyUq6urjp69KgaGxuVlpam4OBgubm5KSIiQrt27Wo2r2k7l61bt8rb21t79+5VSEiIrFarHnvsMdXU1CgzM1NBQUHy8fHRwoUL1dDQYF9n27ZtioqKkoeHh/r3769Zs2aprKys2XkOHTqkqKgoWa1WjRs3TmfPnrWPWb16tX7wgx9o27ZtCgoKkpeXl2bOnKnKyso7+7CBuwhNdADNZGZmqm/fvjp+/Liee+45Pf3005oxY4bGjRunU6dOadKkSZo7d65qamr05Zdf6oEHHpCrq6uys7Nls9k0b9481dfXN1u3tLRUCQkJmjdvngoKCpSTk6NHH33Uvt1LZWWlEhMTdfToUX3++ee69957FR8f7xDIPXr00JtvvqkzZ84oMzNT2dnZWrJkif31/Px8TZw4UcOHD9exY8d09OhRTZs2zeHLAwAAzmz79u1KSEhQVlaWHn/8ccXFxcnDw0OffvqpcnNz5e7ursmTJ+vq1av2OdnZ2fr3v/+tI0eOaMOGDVq1apWmTp0qHx8f5eXlKTk5WQsWLNC//vUvh3OtWrVKy5cv16lTp+Ti4qJZs2ZpyZIl2rhxoz799FMVFRVp5cqV9vFZWVlauXKlXn31VRUUFGjdunVasWKFMjMzHdZdunSpnn/+eRUUFCguLq7F85YtW6aXX35Z+fn5GjZsmBISEm74nQIAgPaSmZmpPn36KC8vT6+//rrWrl2rAwcOtNn6S5cuVXp6ugoKCjRy5EilpaXpt7/9rd555x2dOXNGL7zwgubMmaNPPvnEdI2amhq9+eab+v3vf6/9+/crJydHjzzyiD788EN9+OGH2rZtm371q185NOPr6uqUmpqq06dPa8+ePSopKdETTzzRbO1ly5Zp/fr1OnnypFxcXDRv3jyH14uLi7Vnzx7t3btXe/fu1SeffKL09PQ2+3wAp2UAwDViYmKM8ePH25/X19cbffr0MebOnWs/Vlpaakgyjh07ZqSkpBjBwcHG1atXb7heYmKiMX36dMMwDMNmsxmSjJKSkhbV0tDQYHh4eBgffPCB6ZidO3cafn5+9ucJCQlGdHR0i9YHAMBZxMTEGM8//7zx1ltvGV5eXkZOTo5hGIaxbds2IyQkxGhsbLSPra2tNdzc3Iw///nPhmF8m7VDhgwxGhoa7GNCQkKMCRMm2J835fmOHTsMwzCML774wpBkbN682T5mx44dhiTj0KFD9mNpaWlGSEiI/fnQoUON7du3O9SemppqjB071mHdX/ziFw5jWjrv2nrOnDljSDIKCgpu+fkBANAWrv952DAMY/To0cYrr7xiz6q//OUv9tfKy8sNScbhw4dvufbhw4cNScaePXvsx65cuWJYrVbjs88+cxiblJRkJCQkOMwrLy83DMMwtmzZYkgyioqK7OMXLFhgWK1Wo7Ky0n4sLi7OWLBggWk9J06cMCTZ5zSd5+DBg/Yx+/btMyQZly9fNgzDMFatWmVYrVajoqLCPmbx4sXGmDFjbvn+gbsde6IDaGbkyJH2xz179pSfn5/Cw8PtxwICAiRJZWVlys/P14QJE1q012lERIQmTpyo8PBwxcXFadKkSXrsscfk4+MjSfrPf/6j5cuXKycnR2VlZWpoaFBNTY3OnTtnX+PgwYNKS0tTYWGhKioqVF9frytXrqimpkZWq1X5+fmaMWNGW30UAAB0mF27dqmsrEy5ubkaPXq0JOn06dMqKiqSh4eHw9grV67Yt06TpO9///vq0eN/f2QaEBCgESNG2J835fm1f7YtOWZ+U75fn/lNc6qrq1VcXKykpCTNnz/fPqa+vr7ZPVCioqLsj29n3rX1DBgwQNK33zdCQ0MFAEBHuDaLpG/z6Pr8bI1rM7KoqEg1NTV6+OGHHcZcvXpV9913n+kaVqtVQ4cOtT8PCAhQUFCQ3N3dHY5dW7fNZtPq1at1+vRplZeXq7GxUZJ07tw5DR8+3D7OLIsHDx4sSQoKCnL4XtLWnw/grGiiA2jm+oa4xWJxOGaxWCR9u1ecm5tbi9ft2bOnDhw4oM8++0wff/yxMjIytGzZMuXl5Sk4OFiJiYm6ePGiNm7cqCFDhsjV1VVjx461/7l6SUmJpk6dqqefflqvvvqqfH19dfToUSUlJenq1auyWq23VQ8AAM7kvvvu06lTp/Tuu+8qKipKFotFVVVVioyMtO8rfi1/f3/741tld9Oxph+YbzSvKd+vP9Y0p+keJJs2bdKYMWMc1unZs6fD8z59+tgf3848s+8bAAB0FLP8bPpltfH/25FK326RcrtulJH79u3Td7/7XYdxrq6ut1XjzXK/urpacXFx9i3W/P39de7cOcXFxTlsD3f92jfK4pZ8vwC6IproAFpl5MiRyszMVF1dXYuuRrdYLIqOjlZ0dLRWrlypIUOG6A9/+INefPFF5ebm6u2331Z8fLwk6fz58/rvf/9rn2uz2dTY2Kj169fbv8C8//77zeo5dOiQ1qxZ04bvEgCA9jd06FCtX79esbGx6tmzp9566y2NGjVK7733nvr16ydPT89OrS8gIECBgYH6xz/+odmzZ7f7PAAAnEnTL69LS0vtV4lfe5PROzF8+HC5urrq3LlziomJaW2JpgoLC3Xx4kWlp6dr0KBBkqSTJ0+22/mArogmOoBWefbZZ5WRkaGZM2cqJSVFXl5e+vzzz3X//fcrJCTEYWxeXp4OHTqkSZMmqV+/fsrLy9OFCxcUFhYmSbr33nvtdwyvqKjQ4sWLHa4sv+eee1RXV6eMjAxNmzZNubm5eueddxzOkZKSovDwcD3zzDNKTk5Wr169dPjwYc2YMUN9+/Zt/w8EAIBWGDZsmA4fPqzY2Fi5uLho3bp1+vnPf67p06dr7dq1GjhwoP75z39q9+7dWrJkiQYOHNih9a1Zs0YLFy6Ul5eXJk+erNraWp08eVLl5eV68cUX23weAADOws3NTT/84Q+Vnp6u4OBglZWVafny5a1a08PDQy+//LJeeOEFNTY2avz48frmm2+Um5srT09PJSYmtkntgwcPVq9evZSRkaHk5GT97W9/U2pqapusDXQXPW49BADM+fn5KTs7W1VVVYqJiVFkZKQ2bdp0w6vSPT09deTIEcXHx2vYsGFavny51q9frylTpkiSfvOb36i8vFyjRo3S3LlztXDhQvXr188+PyIiQhs2bNBrr72mESNGKCsrS2lpaQ7nGDZsmD7++GOdPn1a999/v8aOHas//vGPcnHhd4YAgLtDSEiIsrOztWPHDq1YsUJHjhzR4MGD9eijjyosLExJSUm6cuVKp1yZ/tOf/lSbN2/Wli1bFB4erpiYGG3dulXBwcHtMg8AAGfy7rvvqr6+XpGRkVq0aJF+9rOftXrN1NRUrVixQmlpaQoLC9PkyZO1b9++Ns1If39/bd26VTt37tTw4cOVnp6uN954o83WB7oDi3HtZk4AAAAAAAAAAMCOK9EBAAAAAAAAADBBEx0AAAAAAABoheTkZLm7u9/wX3JycmeXB6CV2M4FAAAAAAAAaIWysjJVVFTc8DVPT0+H+30BuPvQRAcAAAAAAAAAwATbuQAAAAAAAAAAYIImOgAAAAAAAAAAJmiiAwAAAAAAAABggiY6AAAAAAAAAAAmaKIDAAAAAAAAAGCCJjoAAAAAAAAAACZoogMAAAAAAAAAYIImOgAAAAAAAAAAJv4P48c82R5uurQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Keeping the first 2 rows of boxplots the same, we now plot the updated chip_exo related boxplots on the bottom row to compare\n", + "data = [new_cc_mcisaac_first_last_data['mcisaac'], new_cc_kemmeren_first_last_data['kemmeren'], new_cc_hu_reimann_first_last_data['hu_reimann'], new_harbison_mcisaac_first_last_data['mcisaac'], new_harbison_kemmeren_first_last_data['kemmeren'], new_harbison_hu_reimann_first_last_data['hu_reimann'], filled_chip_exo_mcisaac_first_last_data[\"mcisaac\"], filled_chip_exo_kemmeren_first_last_data[\"kemmeren\"], filled_chip_exo_hu_reimann_first_last_data[\"hu_reimann\"]]\n", + "binding_labels = [\"cc+mitra\", \"harbison\", \"chip_exo w/ filled rows\"]\n", + "perturbation_labels = [\"mcisaac\", \"kemmeren\", \"hu_reimann\"]\n", + "plot_boxplots(data, binding_labels, perturbation_labels, \"diffs\")" + ] + }, + { + "cell_type": "markdown", + "id": "ad1ba39e-3233-4743-b55f-8bb5d7649068", + "metadata": {}, + "source": [ + "This 3x3 array of boxplots is almost identical to the one above, save for the last row which has been updated to reflect the changes made to the chip_exo dataset. However, these changes seem to produce a more positive bin mean difference which is evident by comparing each boxplot with its previous boxplot in the above 3x3 array. For instance, the previous boxplot which utilized the mcisaac perturbation data had less than half of the data depict a positive differnece. Here, however, it is evident that more than half - nearly 75% of the data - depicts a positive difference between the first and last bin means. Similarly, in the boxplots using the kemmeren and hu_reimann perturbation datasets, the lower quartiles of the data in both boxplots are positive, which compared to the previous boxplots is an improvement, as those boxplots showed less than 75% of the data having a positive bin mean difference. Overall, this change to the chip_exo binding data in which the binning process is performed on tends to produce more positive differences, suggesting a potentially better correlation between the LRR and LRB." + ] + }, + { + "cell_type": "markdown", + "id": "db0f2e59-aebf-4dea-9c19-7dce70fcd102", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### **Boxplots of Pearson Correlations between LRR and LRB**" + ] + }, + { + "cell_type": "markdown", + "id": "455f0f2c-3564-4638-9bb6-3f1c711cb4d7", + "metadata": {}, + "source": [ + "We can alternatively explore using the Pearson correlation coefficient as another means of documenting this relationship between the LRR and LRB. We will plot a similar array of boxplots like the one above, however, this time we will aggregate the Pearson correlation coefficients for the LRR vs. LRB across all TFs to determine whether there exists a similar positive trend here. To do this, we will need to define some new ways to process the data and obtain the correlation coefficients. Then, we will again create an array of these boxplots in the same format as above to compare the results." + ] + }, + { + "cell_type": "markdown", + "id": "0fb18eca-0bbf-4771-a6d4-a2c21e9593a6", + "metadata": {}, + "source": [ + "#### Code" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "b85d9cc0-e513-4aaf-b5ad-96a65e0d3ddf", + "metadata": {}, + "outputs": [], + "source": [ + "def save_pearson_correlation_box_plot_comparisons(tfs: List[str], boolean_list: List[bool], binding_source: List[str], perturbation_sources: List[str], pseudocount: Optional[int] = 1) -> dict:\n", + " \"\"\"\n", + " Calculates the Pearson correlation coefficient between the 'LRR' and 'LRB' columns for each transcription factor (TF) across multiple perturbation sources.\n", + " \n", + " :param tfs: A list of transcription factors to analyze.\n", + " :type tfs: List[str]\n", + " :param boolean_list: A list of boolean values indicating whether the data is aggregated for each transcription factor.\n", + " :type boolean_list: List[bool]\n", + " :param binding_source: A list of sources for the binding data.\n", + " :type binding_source: List[str]\n", + " :param perturbation_sources: A list of sources for the perturbation data.\n", + " :type perturbation_sources: List[str]\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: Optional[int]\n", + " \n", + " :returns: A dictionary where keys are perturbation sources and values are lists of Pearson correlation coefficients for each TF.\n", + " :rtype: Dict[str, List[float]]\n", + " \"\"\"\n", + " # Initialize a dictionary to store Pearson correlation coefficients for each perturbation source\n", + " correlation_data = {source: [] for source in perturbation_sources}\n", + "\n", + " # Suppress RuntimeWarnings for the duration of the following operations\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n", + " \n", + " # Iterate over each transcription factor in the list\n", + " for i in range(len(tfs)):\n", + " for source in perturbation_sources:\n", + " # Process the transcription factor data\n", + " combined_data = process_transcription_factor(str(tfs[i]), boolean_list[i], binding_source[i], source, pseudocount)\n", + "\n", + " # Further process the combined data to calculate ranks and transformations\n", + " plotting_df = process_dataframe(combined_data)\n", + "\n", + " # Ensure there are no NaN values in the 'LRR' and 'LRB' columns before calculating Pearson correlation\n", + " plotting_df = plotting_df.dropna(subset=['neg_log_rank_binding', 'neg_expression_rank_log'])\n", + "\n", + " # Calculate Pearson correlation if there are at least two valid data points\n", + " if len(plotting_df) >= 2:\n", + " correlation, _ = pearsonr(plotting_df['neg_log_rank_binding'], plotting_df['neg_expression_rank_log'])\n", + " correlation_data[source].append(correlation)\n", + " else:\n", + " correlation_data[source].append(float('nan'))\n", + " print(\"TF: {}, correlation: {}\".format(tfs[i], correlation))\n", + " # Remove NaN values from all correlation lists\n", + " for source in correlation_data:\n", + " correlation_data[source] = [x for x in correlation_data[source] if not pd.isnull(x)]\n", + "\n", + " return correlation_data\n", + "\n", + "def compare_pearson_correlation_stored_data_box_plots(stored_data_list: List[dict], labels: List[str]) -> None:\n", + " \"\"\"\n", + " Generates a box plot comparing multiple sets of stored data.\n", + " \n", + " :param stored_data_list: A list of dictionaries containing stored data for each perturbation source.\n", + " :type stored_data_list: List[dict]\n", + " :param labels: A list of labels corresponding to each set of stored data.\n", + " :type labels: List[str]\n", + " \n", + " :returns: None\n", + " :rtype: None\n", + " \"\"\"\n", + " plt.figure(figsize=(10, 6))\n", + " boxplot_data = []\n", + " xtick_labels = []\n", + "\n", + " for idx, stored_data in enumerate(stored_data_list):\n", + " for source, data in stored_data.items():\n", + " boxplot_data.append(data)\n", + " xtick_labels.append(f'{labels[idx]}')\n", + "\n", + " plt.boxplot(boxplot_data, widths=0.6)\n", + " plt.axhline(y=0, color='gray', linestyle='--') # Add a horizontal dotted line at y=0\n", + " plt.xlabel('Perturbation Sources') \n", + " plt.ylabel('Pearson Correlation Between LRB and LRR') \n", + " plt.title('Comparison of Pearson Correlation Between LRB and LRR Across Multiple TFs')\n", + " \n", + " plt.xticks(ticks=range(1, len(xtick_labels) + 1), labels=xtick_labels, rotation=90)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "dd5498e0-d4ae-4666-a163-3956973faf8a", + "metadata": {}, + "source": [ + "#### Application" + ] + }, + { + "cell_type": "markdown", + "id": "282e838b-4fc0-4575-84ac-4aac5ca6b988", + "metadata": {}, + "source": [ + "Now that we've defined the methods, let's run them on the dataset of 62 TFs and compare the boxplots between the combinations of perturbating and binding data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed0e736e-7c46-490b-a834-0286ae82423c", + "metadata": {}, + "outputs": [], + "source": [ + "all_tfs = ['WTM1','MIG2','RIM101','GZF3','ASH1','TEC1','SIP3','SKN7','WTM2','HAA1','MET31','CRZ1','CHA4','ZAP1','SKO1','FZF1','HAP2','HAP3','HAP5','INO4','RTG1','MOT3','CBF1','MSN2','RTG3','RSF2','HIR2','SIP4','UME1','CIN5','ROX1','XBP1','RDR1','PDR3','RLM1','SFL1','SMP1','PHD1','SUT1','SOK2','STP2','AFT2','YRR1','GAL4','LEU3','SWI6','ACE2','RGM1','GCN4','MIG3','STB5','RFX1','ARG81','AZF1','SFP1','GTS1','FKH1','YOX1','FKH2','DIG1','MET28','RGT1']\n", + "boolean_list = [True]*31 + [False]*31\n", + "cc_to_mitra_ratio_in_all = [\"cc\"]*38+[\"mitra\"]*24" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "458db7cc-f506-483c-a808-2052314d5889", + "metadata": {}, + "outputs": [], + "source": [ + "#saving the data to plot as a joint boxplot\n", + "new_cc_kemmeren_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, perturbation_sources = [\"kemmeren\"])\n", + "new_cc_mcisaac_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, perturbation_sources = [\"mcisaac\"])\n", + "new_cc_hu_reimann_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, perturbation_sources = [\"hu_reimann\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "060f9e89-5922-4c9d-8572-45a5033b7576", + "metadata": {}, + "outputs": [], + "source": [ + "new_harbison_kemmeren_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, [\"harbison\"]*100, perturbation_sources = [\"kemmeren\"])\n", + "new_harbison_mcisaac_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, [\"harbison\"]*100, perturbation_sources = [\"mcisaac\"])\n", + "new_harbison_hu_reimann_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, [\"harbison\"]*100, perturbation_sources = [\"hu_reimann\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "482621cf-bc54-4905-98d3-135f3aa138df", + "metadata": {}, + "outputs": [], + "source": [ + "chip_exo_kemmeren_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"kemmeren\"])\n", + "chip_exo_mcisaac_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"mcisaac\"])\n", + "chip_exo_reimann_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"hu_reimann\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 382, + "id": "a9c7ba15-2c79-4516-b651-eb6e112b1ff1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = [new_cc_mcisaac_pearson_correlations['mcisaac'], new_cc_kemmeren_pearson_correlations['kemmeren'], new_cc_hu_reimann_pearson_correlations['hu_reimann'], new_harbison_mcisaac_pearson_correlations['mcisaac'], new_harbison_kemmeren_pearson_correlations['kemmeren'], new_harbison_hu_reimann_pearson_correlations['hu_reimann'],chip_exo_mcisaac_pearson_correlations['mcisaac'], chip_exo_kemmeren_pearson_correlations['kemmeren'], chip_exo_reimann_pearson_correlations['hu_reimann']]\n", + "binding_labels = [\"cc+mitra\", \"harbison\", \"chip_exo\"]\n", + "perturbation_labels = [\"mcisaac\", \"kemmeren\", \"hu_reimann\"]\n", + "plot_boxplots(data, binding_labels, perturbation_labels, \"correlations\")" + ] + }, + { + "cell_type": "markdown", + "id": "57544004-6556-448a-a4a4-4b09e602df67", + "metadata": {}, + "source": [ + "This boxplot is organized exactly the same as the boxplots above. However, in this case, the data being plotted by the boxplots is using the pearson correlation between the LRR and LRB values for a particular TF, aggregating this data across all 62 TFs.\n", + "\n", + "This exhibits a similar overall trend with the 3x3 arrays of boxplots above containing the binned mean differences between the first and last bins. This is good news! It means that even without binning, there is somewhat of a trend observed between the LRR and LRB, even if it is not very significant. Looking at the boxplots, it appears that this trend is generally most evident in the chip_exo binding data. However, it is important to clarify that the chip_exo data has less than 100 rows of data in general. This means that for example, in the boxplot using the kemmeren perturbation data, a perfect correlation of 1.00 is achieved. Upon closer examination, this is due to the fact that the chip_exo data had only 2 rows of data associated with it, and when ranking the LRR and LRB, they both were assigned the same ranks resulting in a perfect pearson correlation. As such, it is important to keep in mind the property of the chip_exo binding data when assessing the plots in the bottom row as they may look much better than reality.\n", + "\n", + "Looking at the other two rows, it is more evident that the Calling Cards + mitra binding datasets produce better correlations than using the harbison binding data, as the medians of the boxplots in the top row are all greater than zero, whereas only one median in the bottom row is positive. It also seems that using the CC + mitra binding data and the kemmeren perturbation data yields the most identifiable trend within that row, while the harbison binding and mcisaac perturbation data produce the most positive correlations in that row. " + ] + }, + { + "cell_type": "markdown", + "id": "f43a4a58-8926-4d18-9064-564a0357a0ad", + "metadata": {}, + "source": [ + "To obtain a more accurate idea of how the Pearson correlation boxplots should look like by incorporating data on the non-responsive genes for the chip_exo binding data, we can take the same approach used to create the boxplots above and modify the method in which the chip_exo data is accessed in order to include non-responsive data points for all of the non-responsive genes. Keep in mind that the enrichment and pvalues are chosen to be 0 and the smallest insignificant pvalue of 0.05, respectively. We will re-plot the 3x3 array of Pearson correlation boxplots to determine how the bottom row of boxplots will change." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1dfc55a-d949-471d-a2a6-d8def81d3b53", + "metadata": {}, + "outputs": [], + "source": [ + "async def process_transcription_factor_async(tf_name: str, is_aggregated: bool, binding_source: str, perturbation_source: str, pseudocount: int = 1) -> pd.DataFrame: \n", + " \"\"\"\n", + " Process transcription factor data by retrieving and merging binding and perturbation datasets.\n", + "\n", + " :param tf_name: The name of the transcription factor, e.g., \"AR080\".\n", + " :type tf_name: str\n", + " :param is_aggregated: Indicates whether the data is aggregated.\n", + " :type is_aggregated: bool\n", + " :param binding_source: The source of the binding data, e.g., \"cc\" or \"harbison\".\n", + " :type binding_source: str\n", + " :param perturbation_source: The source of the perturbation data, e.g., \"mcisaac\".\n", + " :type perturbation_source: str\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: int, optional\n", + "\n", + " :returns: A DataFrame containing the combined and processed binding and perturbation data.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " # Ensure the TF name is in uppercase to maintain consistency\n", + " tf_name_upper = tf_name.upper()\n", + " \n", + " # Initialize API for binding data\n", + " pss_api_tf = PromoterSetSigAPI()\n", + "\n", + " # Access the relevant data depending on the binding source and aggregation status\n", + " if binding_source == \"cc\":\n", + " if is_aggregated:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"datasource\": \"brent_nf_cc\", \"aggregated\": \"true\"})\n", + " else:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"workflow\": \"nf_core_callingcards_1_0_0\", \"data_usable\": \"pass\"})\n", + " elif binding_source == \"harbison\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"4\"})\n", + " elif binding_source == \"mitra\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"2\"})\n", + " elif binding_source == \"chip_exo\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"3\"})\n", + "\n", + " # Asynchronously read the binding data from the API\n", + " tf_pss = await pss_api_tf.read(retrieve_files=True)\n", + " # Get the ID of the retrieved binding data\n", + " id = tf_pss.get(\"metadata\")[\"id\"][0]\n", + " # Extract the binding data using the ID\n", + " binding_df = tf_pss.get(\"data\").get(str(id))\n", + "\n", + " # Initialize API for perturbation data\n", + " expression = ExpressionAPI()\n", + "\n", + " # Map perturbation source to corresponding source number\n", + " source_mapping = {\n", + " \"mcisaac\": \"7\",\n", + " \"hu_reimann\": \"5\",\n", + " \"kemmeren\": \"6\"\n", + " }\n", + " source_number = source_mapping.get(perturbation_source, \"unknown\")\n", + " \n", + " # Push parameters to retrieve the perturbation data\n", + " if perturbation_source == \"mcisaac\":\n", + " expression.push_params({\"regulator_symbol\": tf_name_upper, \"source\": source_number, \"time\": \"15\"})\n", + " else:\n", + " expression.push_params({\"regulator_symbol\": tf_name_upper, \"source\": source_number})\n", + "\n", + " # Asynchronously read the perturbation data from the API\n", + " expression_res = await expression.read(retrieve_files=True)\n", + " # Get the ID of the retrieved perturbation data\n", + " id = expression_res.get(\"metadata\")[\"id\"][0]\n", + " # Extract the perturbation data using the ID\n", + " expression_df = expression_res.get(\"data\").get(str(id))\n", + "\n", + " # Read perturbation data\n", + " perturbation_data = expression_df\n", + " # Read binding data\n", + " binding_data = binding_df\n", + "\n", + " # Rename columns in binding data for consistency and clarity\n", + " if binding_source == \"cc\":\n", + " binding_data.rename(columns={\"callingcards_enrichment\": \"effect\", \"poisson_pval\": \"pvalue\"}, inplace=True)\n", + " elif binding_source == \"harbison\":\n", + " binding_data.rename(columns={\"pval\": \"pvalue\"}, inplace=True)\n", + " elif binding_source == \"mitra\":\n", + " binding_data.rename(columns={\"callingcards_enrichment\": \"effect\", \"poisson_pval\": \"pvalue\"}, inplace=True)\n", + " elif binding_source == \"chip_exo\":\n", + " binding_data.rename(columns={\"max_fc\": \"effect\", \"min_pval\": \"pvalue\"}, inplace=True)\n", + "\n", + " # Optional: here you can modify the pseudocount as needed. The default pseudocount is set to 1.\n", + " # Calculate the effect size for binding data using the provided formula\n", + " if binding_source == \"cc\":\n", + " binding_data['effect'] = (binding_data['experiment_hops'] / binding_data['experiment_total_hops']) / \\\n", + " ((binding_data['background_hops'] + pseudocount) / binding_data['background_total_hops'])\n", + "\n", + " missing_values = set(perturbation_data[\"target_locus_tag\"]) - set(binding_data[\"target_locus_tag\"])\n", + "\n", + " # Add missing rows to the binding data with enrichment = 0 and pvalue = 1\n", + " if missing_values:\n", + " missing_rows = pd.DataFrame({\n", + " 'target_locus_tag': list(missing_values),\n", + " 'effect': 0,\n", + " 'pvalue': -4.322 #since this is for the chipexo data, we find log2 (0.05) \n", + " })\n", + " binding_data = pd.concat([binding_data, missing_rows], ignore_index=True)\n", + "\n", + " # Merge the binding data and perturbation data on the 'target_locus_tag' column\n", + " combined_data = pd.merge(binding_data, perturbation_data, on='target_locus_tag', suffixes=('_binding', '_perturbation'))\n", + "\n", + " # # Assert that the length of combined_data is the minimum of the lengths of binding_data and perturbation_data\n", + " # assert len(combined_data) <= min(len(binding_data), len(perturbation_data)), \\\n", + " # f\"Length of combined_data ({len(combined_data)}) is not equal to the minimum of lengths of binding_data ({len(binding_data)}) and perturbation_data ({len(perturbation_data)})\"\n", + "\n", + " # Keep only the necessary columns in the combined data\n", + " combined_data = combined_data[['target_locus_tag', 'effect_binding', 'effect_perturbation', 'pvalue_binding']]\n", + "\n", + " # Reorder the combined data by the smallest 'pvalue_binding' values\n", + " combined_data = combined_data.sort_values(by='pvalue_binding')\n", + "\n", + " # Apply transformations:\n", + " # - Take the absolute value of 'effect_perturbation'\n", + " # - Calculate the negative log10 of 'pvalue_binding'\n", + " # - Calculate the log10 of 'effect_binding'\n", + " combined_data['effect_perturbation'] = combined_data['effect_perturbation'].abs()\n", + " combined_data['neg_log_pvalue_binding'] = -np.log10(combined_data['pvalue_binding'])\n", + " combined_data['log_enrichment'] = np.log10(combined_data['effect_binding'])\n", + "\n", + " # Return the processed combined data as a DataFrame\n", + " return combined_data\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8f1ad36-d128-490b-9d6e-b82fd8749fc1", + "metadata": {}, + "outputs": [], + "source": [ + "filled_chip_exo_kemmeren_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"kemmeren\"])\n", + "filled_chip_exo_mcisaac_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"mcisaac\"])\n", + "filled_chip_exo_reimann_pearson_correlations = save_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, [\"chip_exo\"]*100, perturbation_sources = [\"hu_reimann\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0eb95c38-46c6-45a3-a9c9-c577e4a7767b", + "metadata": {}, + "outputs": [], + "source": [ + "#new updating process dataframe\n", + "data = [new_cc_mcisaac_pearson_correlations['mcisaac'], new_cc_kemmeren_pearson_correlations['kemmeren'], new_cc_hu_reimann_pearson_correlations['hu_reimann'], new_harbison_mcisaac_pearson_correlations['mcisaac'], new_harbison_kemmeren_pearson_correlations['kemmeren'], new_harbison_hu_reimann_pearson_correlations['hu_reimann'], filled_chip_exo_mcisaac_pearson_correlations['mcisaac'], filled_chip_exo_kemmeren_pearson_correlations['kemmeren'], filled_chip_exo_reimann_pearson_correlations['hu_reimann']]\n", + "binding_labels = [\"cc+mitra\", \"harbison\", \"chip_exo w/ filled rows\"]\n", + "perturbation_labels = [\"mcisaac\", \"kemmeren\", \"hu_reimann\"]\n", + "plot_boxplots(data, binding_labels, perturbation_labels, \"correlations\")" + ] + }, + { + "cell_type": "code", + "execution_count": 383, + "id": "640b6789-43c5-4f5a-9678-446027b6ccbb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = [new_cc_mcisaac_pearson_correlations['mcisaac'], new_cc_kemmeren_pearson_correlations['kemmeren'], new_cc_hu_reimann_pearson_correlations['hu_reimann'], new_harbison_mcisaac_pearson_correlations['mcisaac'], new_harbison_kemmeren_pearson_correlations['kemmeren'], new_harbison_hu_reimann_pearson_correlations['hu_reimann'], filled_chip_exo_mcisaac_pearson_correlations['mcisaac'], filled_chip_exo_kemmeren_pearson_correlations['kemmeren'], filled_chip_exo_reimann_pearson_correlations['hu_reimann']]\n", + "binding_labels = [\"cc+mitra\", \"harbison\", \"chip_exo w/ filled rows\"]\n", + "perturbation_labels = [\"mcisaac\", \"kemmeren\", \"hu_reimann\"]\n", + "plot_boxplots(data, binding_labels, perturbation_labels, \"correlations\")" + ] + }, + { + "cell_type": "markdown", + "id": "707def82-23b9-4d16-af0c-29eefa0acd7e", + "metadata": {}, + "source": [ + "Before we compare the last row of updated chip_exo data with the 3x3 array of boxplots above, it is important to note that the scale on these two boxplots is not the same. On the above array of boxplots, the vertical scale ranges from -1.00 to 1.00. Here, however, the scale is halved, ranging only from -0.50 to 0.50. With this in mind, it is more apparent that adding the non-responsive genes to the chip_exp binding data results in weaker positive correlations between the LRR and LRB. This is likely due to the fact that many new rows of data representing non-responsible genes have been added, which greatly outnumber the original amount of data in the chip_exo binding data. Thus, these boxplots seem more plausible, and it is good that they continue to show a somewhat positive correlation, albeit not as extreme as before." + ] + }, + { + "cell_type": "markdown", + "id": "6fee7e96-95ac-4ac3-b690-afc73388792a", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## **Further Approaches to Ranking the Binding and Perturbation Data**" + ] + }, + { + "cell_type": "markdown", + "id": "7dee498c-24e9-44c4-bda9-ff806c93da77", + "metadata": {}, + "source": [ + "Our above analysis focused on ranking the binding and pertubation data in the same way each time. However, due to the nature of the data, there are often identical values which are assigned the same ranking in both the binding and perturbation data.\n", + "\n", + "As a reminder, the binding data was ranked according to the poisson pvalue, even through two other metrics exist: the binding enrichment score and the hypergeometric pvalue. It is worth considering whether alternative ranking approaches can result in less ties and ultimately, more desirable trends as observed on the boxplots of the binned mean data differences and Pearson correlations.\n", + "\n", + "In the data exploration above, we solely chose to rank the perturbation data according to the magnitude of the perturbation effect. For the mcisaac perturbation data specifically, there exist mutiple timepoints in which there is effect data. The idea of assigning ranks to the data by averaging between two perturbation sets is another method that we can explore to determine whether this improve the binned boxplots above. " + ] + }, + { + "cell_type": "markdown", + "id": "d1843c72-4784-43cd-b21d-d1cd6cf7489a", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### **Which Approaches of Ranking the Perturbation Data Yields the Best Trends?**" + ] + }, + { + "cell_type": "markdown", + "id": "93aa3440-81cf-4476-b595-ddedc73ea74b", + "metadata": {}, + "source": [ + "#### **1) Using Average Ranking For Multiple Timepoints in the mcisaac Perturbation Data**" + ] + }, + { + "cell_type": "markdown", + "id": "63952ab1-04cf-4461-92bf-ac755bb9ba01", + "metadata": {}, + "source": [ + "It's interesting to consider whether taking an average ranking might result in a stronger trend being depicted on the boxplots for the Pearson correlation or first and last binned mean differences. The motivation for this comes from the fact that in the plots above, the highest value along the y-axis is around -3, and when taking the reverse of the negative log this results in a rank around 1000. If the highest rank is 1000, this implies many ties occuring between data points which can result in a lower resolution of the desired trend. Thus, it is worth exploring whether assigning each gene an average rank across the different timepoints reported in the mcisaac data may produce better rankings. The following methods below will perform this averaging of the ranks on the mcisaac perturbation data across 4 timepoints and then combine the perturbation and binding datasets since the original methods do not support the implementation of this ranking method. Note that we will use the CC + mitra data as the binding data in all of the perturbation ranking experiments." + ] + }, + { + "cell_type": "markdown", + "id": "9a5b6d15-6dcc-416d-ba90-018c1644c30c", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "#### Code" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "7ee12b9b-cd23-4ddd-b54c-6b87b6d5d824", + "metadata": {}, + "outputs": [], + "source": [ + "async def process_perturbation_data_async(tf_name: str, perturbation_source: str) -> pd.DataFrame:\n", + " \"\"\"\n", + " Process perturbation data by retrieving data for different timepoints, ranking genes,\n", + " and calculating the average rank for each gene across timepoints.\n", + " \n", + " :param tf_name: The name of the transcription factor, e.g., \"AR080\".\n", + " :type tf_name: str\n", + " :param perturbation_source: The source of the perturbation data, e.g., \"mcisaac\".\n", + " :type perturbation_source: str\n", + " \n", + " :returns: A DataFrame containing the genes and their average rankings.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " # Ensure the TF name is in uppercase to maintain consistency\n", + " tf_name_upper = tf_name.upper()\n", + " \n", + " # Initialize API for perturbation data\n", + " expression = ExpressionAPI()\n", + " \n", + " if perturbation_source == \"mcisaac\":\n", + " timepoints = [\"15\", \"30\", \"45\", \"90\"]\n", + " all_timepoint_dfs = []\n", + "\n", + " for time in timepoints:\n", + " source_mapping = {\n", + " \"mcisaac\": \"7\",\n", + " \"hu_reimann\": \"5\",\n", + " \"kemmeren\": \"6\"\n", + " }\n", + " source_number = source_mapping.get(perturbation_source, \"unknown\")\n", + " \n", + " # Push parameters to retrieve the perturbation data\n", + " if perturbation_source == \"mcisaac\":\n", + " expression.push_params({\"regulator_symbol\": tf_name_upper, \"source\": source_number, \"time\": \"15\"})\n", + " else:\n", + " expression.push_params({\"regulator_symbol\": tf_name_upper, \"source\": source_number})\n", + " expression_res = await expression.read(retrieve_files=True)\n", + " id = expression_res.get(\"metadata\")[\"id\"][0]\n", + " expression_df = expression_res.get(\"data\").get(str(id))\n", + " expression_df['time'] = time\n", + " expression_df['effect'] = expression_df['effect'].abs()\n", + " all_timepoint_dfs.append(expression_df)\n", + "\n", + " combined_expression_df = pd.concat(all_timepoint_dfs)\n", + "\n", + " # Rank genes based on the perturbation effect within each timepoint\n", + " ranked_dfs = []\n", + " for time in timepoints:\n", + " timepoint_df = combined_expression_df[combined_expression_df['time'] == time].copy()\n", + " timepoint_df['rank'] = rankdata(-abs(timepoint_df['effect']), method='average') \n", + " ranked_dfs.append(timepoint_df)\n", + " \n", + " # Combine ranked dataframes\n", + " ranked_combined_df = pd.concat(ranked_dfs)\n", + " \n", + " avg_ranks = {}\n", + " for gene in ranked_combined_df['target_locus_tag'].unique():\n", + " gene_data = ranked_combined_df[ranked_combined_df['target_locus_tag'] == gene]\n", + " avg_rank = gene_data['rank'].mean()\n", + " avg_effect = gene_data['effect'].mean()\n", + " avg_ranks[gene] = (avg_effect, avg_rank)\n", + " \n", + " avg_ranks_df = pd.DataFrame(list(avg_ranks.items()), columns=['target_locus_tag', 'values'])\n", + " avg_ranks_df[['effect', 'avg_rank']] = pd.DataFrame(avg_ranks_df['values'].tolist(), index=avg_ranks_df.index)\n", + " avg_ranks_df = avg_ranks_df.drop(columns=['values'])\n", + " avg_ranks_df['neg_expression_rank_log'] = -np.log10(avg_ranks_df['avg_rank'])\n", + "\n", + " return avg_ranks_df" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "7ada8c87-4a3b-4a1c-b01a-b7101476f84e", + "metadata": {}, + "outputs": [], + "source": [ + "def process_perturbation_data(tf_name: str, perturbation_source: str) -> pd.DataFrame:\n", + " \"\"\"\n", + " Processes transcription factor data synchronously by invoking an asynchronous function.\n", + " \n", + " This function runs the asynchronous `process_transcription_factor_async` function synchronously to handle \n", + " transcription factor data processing. It retrieves the event loop, runs the asynchronous function, \n", + " and returns the processed DataFrame.\n", + " \n", + " :param tf_name: The name of the transcription factor.\n", + " :type tf_name: str\n", + " :param is_aggregated: A boolean flag indicating whether the data is aggregated.\n", + " :type is_aggregated: bool\n", + " :param perturbation_source: The source of the perturbation data.\n", + " :type perturbation_source: str\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: int, optional\n", + " \n", + " :returns: A DataFrame containing the processed transcription factor data.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " loop = asyncio.get_event_loop()\n", + " return loop.run_until_complete(process_perturbation_data_async(tf_name, perturbation_source))" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "435f814b-7682-4c8a-80a0-26537a5b3bf1", + "metadata": {}, + "outputs": [], + "source": [ + "async def access_binding_data_async(tf_name: str, is_aggregated: bool, binding_source: str, pseudocount: Optional[int] = 1) -> pd.DataFrame: \n", + " \"\"\"\n", + " Process transcription factor data by retrieving and merging binding and perturbation datasets.\n", + " \n", + " :param tf_name: The name of the transcription factor, e.g., \"AR080\".\n", + " :type tf_name: str\n", + " :param is_aggregated: Indicates whether the data is aggregated. You can check if the TF belongs to the list above.\n", + " :type is_aggregated: bool\n", + " :param perturbation_source: The source of the perturbation data, e.g., \"mcisaac\".\n", + " :type perturbation_source: str\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: int, optional\n", + " \n", + " :returns: A DataFrame containing the combined and processed binding and perturbation data.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " # Ensure the TF name is in uppercase to maintain consistency\n", + " tf_name_upper = tf_name.upper()\n", + " \n", + " # Initialize API for binding data\n", + " pss_api_tf = PromoterSetSigAPI()\n", + "\n", + " # Access the relevant data depending on whether the data is aggregated or not\n", + " if binding_source == \"cc\":\n", + " if is_aggregated:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"datasource\": \"brent_nf_cc\", \"aggregated\": \"true\"})\n", + " else:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"workflow\": \"nf_core_callingcards_1_0_0\", \"data_usable\": \"pass\"})\n", + " elif binding_source == \"harbison\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"4\"})\n", + " elif binding_source == \"mitra\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"2\"})\n", + "\n", + " # Asynchronously read the binding data from the API\n", + " tf_pss = await pss_api_tf.read(retrieve_files=True)\n", + " # Get the ID of the retrieved binding data\n", + " id = tf_pss.get(\"metadata\")[\"id\"][0]\n", + " # Extract the binding data using the ID\n", + " binding_df = tf_pss.get(\"data\").get(str(id))\n", + "\n", + " # Calculate binding rank with average ties method\n", + " if binding_source == \"cc\":\n", + " binding_df['binding_rank'] = rankdata(binding_df['poisson_pval'], method='average')\n", + " elif binding_source == \"harbison\":\n", + " binding_df['binding_rank'] = rankdata(binding_df['pval'], method='average')\n", + " elif binding_source == \"mitra\":\n", + " binding_df['binding_rank'] = rankdata(binding_df['poisson_pval'], method='average')\n", + "\n", + " # Calculate log transform of the binding rank\n", + " binding_df['neg_log_rank_binding'] = -np.log10(rankdata(binding_df['binding_rank'], method='average'))\n", + " \n", + " return binding_df" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "93f5ea88-5a02-4038-bf49-0e2cd734c47a", + "metadata": {}, + "outputs": [], + "source": [ + "def access_binding_data(tf_name: str, is_aggregated: bool, binding_source: str, pseudocount: Optional[int] = 1) -> pd.DataFrame:\n", + " \"\"\"\n", + " Processes transcription factor data synchronously by invoking an asynchronous function.\n", + " \n", + " This function runs the asynchronous `process_transcription_factor_async` function synchronously to handle \n", + " transcription factor data processing. It retrieves the event loop, runs the asynchronous function, \n", + " and returns the processed DataFrame.\n", + " \n", + " :param tf_name: The name of the transcription factor.\n", + " :type tf_name: str\n", + " :param is_aggregated: A boolean flag indicating whether the data is aggregated.\n", + " :type is_aggregated: bool\n", + " :param perturbation_source: The source of the perturbation data.\n", + " :type perturbation_source: str\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: int, optional\n", + " \n", + " :returns: A DataFrame containing the processed transcription factor data.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " loop = asyncio.get_event_loop()\n", + " return loop.run_until_complete(access_binding_data_async(tf_name, is_aggregated, binding_source, pseudocount))" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "da378a0c-f5f9-40c1-af68-9223693a8fce", + "metadata": {}, + "outputs": [], + "source": [ + "def process_and_merge_data(tf_name: str, is_aggregated: bool, binding_source: str, perturbation_source: str, pseudocount: Optional[int] = 1) -> pd.DataFrame:\n", + " \"\"\"\n", + " Process binding and perturbation data and merge them.\n", + " \n", + " :param tf_name: The name of the transcription factor, e.g., \"AR080\".\n", + " :type tf_name: str\n", + " :param is_aggregated: Indicates whether the data is aggregated.\n", + " :type is_aggregated: bool\n", + " :param perturbation_source: The source of the perturbation data, e.g., \"mcisaac\".\n", + " :type perturbation_source: str\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: int, optional\n", + " \n", + " :returns: Merged DataFrame with the specified columns.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " binding_df = access_binding_data(tf_name, is_aggregated, binding_source, pseudocount)\n", + " perturbation_df = process_perturbation_data(tf_name, perturbation_source)\n", + " # Merge the dataframes on 'regulator_locus_tag'\n", + " merged_df = pd.merge(binding_df, perturbation_df, on='target_locus_tag')\n", + " \n", + " # Select the desired columns\n", + " result_df = merged_df[['target_locus_tag', 'neg_log_rank_binding', 'neg_expression_rank_log']] \n", + " return result_df" + ] + }, + { + "cell_type": "code", + "execution_count": 307, + "id": "35d9c287-07ee-4012-a8ea-a81677a8cffe", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
target_locus_tagneg_log_rank_bindingneg_expression_rank_log
0YAL069W-3.231470-3.495128
1YAL068C-3.056524-3.495128
2YAL067C-3.160769-3.495128
3YAL066W-2.957847-3.495128
4YAL065C-2.548389-3.495128
\n", + "
" + ], + "text/plain": [ + " target_locus_tag neg_log_rank_binding neg_expression_rank_log\n", + "0 YAL069W -3.231470 -3.495128\n", + "1 YAL068C -3.056524 -3.495128\n", + "2 YAL067C -3.160769 -3.495128\n", + "3 YAL066W -2.957847 -3.495128\n", + "4 YAL065C -2.548389 -3.495128" + ] + }, + "execution_count": 307, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#this is how you would access the combined binding / perturbation data using this ranking approach\n", + "combined_data = process_and_merge_data(\"ARO80\", False, \"cc\", \"mcisaac\")\n", + "combined_data.head()" + ] + }, + { + "cell_type": "markdown", + "id": "ee417901-f57a-4bef-b050-9481da02ef63", + "metadata": {}, + "source": [ + "Let's investigate the correlations between the LRR and LRB when ranking according to this scheme. We will need to create slightly different methods to accomodate for this new way of ranking the data." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "e7d28c09-66c9-4238-8e4f-1c6b373a2797", + "metadata": {}, + "outputs": [], + "source": [ + "def save_ranked_pearson_correlation_box_plot_comparisons(tfs: List[str], boolean_list: List[bool], binding_source: List[str], perturbation_sources: List[str], pseudocount: Optional[int] = 1) -> dict:\n", + " \"\"\"\n", + " Calculates the Pearson correlation coefficient between the 'LRR' and 'LRB' columns for each transcription factor (TF) across multiple perturbation sources.\n", + " \n", + " :param tfs: A list of transcription factors to analyze.\n", + " :type tfs: List[str]\n", + " :param boolean_list: A list of boolean values indicating whether the data is aggregated for each transcription factor.\n", + " :type boolean_list: List[bool]\n", + " :param binding_source: A list of sources for the binding data.\n", + " :type binding_source: List[str]\n", + " :param perturbation_sources: A list of sources for the perturbation data.\n", + " :type perturbation_sources: List[str]\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: Optional[int]\n", + " \n", + " :returns: A dictionary where keys are perturbation sources and values are lists of Pearson correlation coefficients for each TF.\n", + " :rtype: Dict[str, List[float]]\n", + " \"\"\"\n", + " # Initialize a dictionary to store Pearson correlation coefficients for each perturbation source\n", + " correlation_data = {source: [] for source in perturbation_sources}\n", + "\n", + " # Suppress RuntimeWarnings for the duration of the following operations\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n", + " \n", + " # Iterate over each transcription factor in the list\n", + " for i in range(len(tfs)):\n", + " for source in perturbation_sources:\n", + " # Further process the combined data to calculate ranks and transformations\n", + " plotting_df = process_and_merge_data(str(tfs[i]), boolean_list[i], binding_source[i], source, pseudocount)\n", + "\n", + " # Ensure there are no NaN values in the 'LRR' and 'LRB' columns before calculating Pearson correlation\n", + " plotting_df = plotting_df.dropna(subset=['neg_log_rank_binding', 'neg_expression_rank_log'])\n", + "\n", + " # Calculate Pearson correlation if there are at least two valid data points\n", + " if len(plotting_df) >= 2:\n", + " correlation, _ = pearsonr(plotting_df['neg_log_rank_binding'], plotting_df['neg_expression_rank_log'])\n", + " correlation_data[source].append(correlation)\n", + " else:\n", + " correlation_data[source].append(float('nan'))\n", + "\n", + " # Remove NaN values from all correlation lists\n", + " for source in correlation_data:\n", + " correlation_data[source] = [x for x in correlation_data[source] if not pd.isnull(x)]\n", + "\n", + " return correlation_data\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ed87b35-ac57-44f4-a539-9b1692b99695", + "metadata": {}, + "outputs": [], + "source": [ + "def adjacent_differences_store_ranked_data(tfs: List[str], boolean_list: List[bool], binding_source: List[str], perturbation_sources: List[str], bins: int, pseudocount: Optional[int] = 1) -> dict:\n", + " \"\"\"\n", + " Stores the differences between adjacent bins for a list of transcription factors.\n", + " \n", + " This function processes transcription factor data, calculates differences between the means of adjacent bins,\n", + " and stores these differences across multiple transcription factors.\n", + " \n", + " :param tfs: A list of transcription factors that you want to plot.\n", + " :type tfs: List[str]\n", + " :param boolean_list: A list of boolean values indicating whether the data is aggregated for each transcription factor.\n", + " :type boolean_list: List[bool]\n", + " :param perturbation_sources: A list of sources of the perturbation data.\n", + " :type perturbation_sources: List[str]\n", + " :param bins: The number of bins to create.\n", + " :type bins: int\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: Optional[int]\n", + " \n", + " :returns: A dictionary containing the stored data for each perturbation source.\n", + " :rtype: dict\n", + " \"\"\"\n", + " # Initialize a dictionary to store differences between adjacent bins for each perturbation source\n", + " diff_data = {source: [[] for _ in range(bins - 1)] for source in perturbation_sources}\n", + "\n", + " # Suppress RuntimeWarnings for the duration of the following operations\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n", + "\n", + " # Iterate over each transcription factor in the list\n", + " for i in range(len(tfs)):\n", + " print(str(i) + tfs[i])\n", + " for source in perturbation_sources:\n", + " # Process the transcription factor data\n", + " plotting_df = process_and_merge_data(str(tfs[i]), boolean_list[i], binding_source[i], source, pseudocount)\n", + " \n", + " # Create bins for the 'neg_log_rank_binding' column using the specified number of bins\n", + " plotting_df['bin'] = create_bins(plotting_df, 'neg_log_rank_binding', num_bins=bins)\n", + " \n", + " # Calculate the mean of 'neg_expression_rank_log' for each bin\n", + " binned_means = plotting_df.groupby('bin', observed=True)['neg_expression_rank_log'].mean().reset_index()\n", + " \n", + " # Initialize a list to store the differences between adjacent bins\n", + " binned_mean_diffs = []\n", + " \n", + " # Calculate the differences between the means of adjacent bins\n", + " for j in range(bins - 1):\n", + " binned_mean_diffs.append(binned_means[\"neg_expression_rank_log\"][j+1] - binned_means[\"neg_expression_rank_log\"][j])\n", + " \n", + " # Append the differences to the corresponding list in diff_data\n", + " for j in range(bins - 1):\n", + " diff_data[source][j].append(binned_mean_diffs[j])\n", + "\n", + " # Remove NaN values from all bin difference lists\n", + " for source in diff_data:\n", + " diff_data[source] = [[x for x in bin_diff if not pd.isnull(x)] for bin_diff in diff_data[source]]\n", + "\n", + " return diff_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0bb863c6-15f7-47a6-aa18-4a9459df850b", + "metadata": {}, + "outputs": [], + "source": [ + "def first_last_differences_store_ranked_data(tfs: List[str], boolean_list: List[bool], binding_source: List[str], perturbation_sources: List[str], bins: int, pseudocount: Optional[int] = 1) -> dict:\n", + " \"\"\"\n", + " Stores the differences between adjacent bins for a list of transcription factors.\n", + " \n", + " This function processes transcription factor data, calculates differences between the means of adjacent bins,\n", + " and stores these differences across multiple transcription factors.\n", + " \n", + " :param tfs: A list of transcription factors that you want to plot.\n", + " :type tfs: List[str]\n", + " :param boolean_list: A list of boolean values indicating whether the data is aggregated for each transcription factor.\n", + " :type boolean_list: List[bool]\n", + " :param perturbation_sources: A list of sources of the perturbation data.\n", + " :type perturbation_sources: List[str]\n", + " :param bins: The number of bins to create.\n", + " :type bins: int\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: Optional[int]\n", + " \n", + " :returns: A dictionary containing the stored data for each perturbation source.\n", + " :rtype: dict\n", + " \"\"\"\n", + " # Initialize a dictionary to store differences between the first and last bins for each perturbation source\n", + " diff_data = {source: [] for source in perturbation_sources}\n", + "\n", + " # Suppress RuntimeWarnings for the duration of the following operations\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n", + "\n", + " # Iterate over each transcription factor in the list\n", + " for i in range(len(tfs)):\n", + " print(tfs[i])\n", + " for source in perturbation_sources:\n", + " # Further process the combined data to calculate ranks and transformations\n", + " plotting_df = process_and_merge_data(str(tfs[i]), boolean_list[i], binding_source[i], source, pseudocount)\n", + " \n", + " # Create bins for the 'neg_log_rank_binding' column using the specified number of bins\n", + " plotting_df['bin'] = create_bins(plotting_df, 'neg_log_rank_binding', num_bins=bins)\n", + " \n", + " # Calculate the mean of 'neg_expression_rank_log' for each bin\n", + " binned_means = plotting_df.groupby('bin', observed=True)['neg_expression_rank_log'].mean().reset_index()\n", + " \n", + " # Calculate the difference between the first and last bin means\n", + " first_last_diff = binned_means[\"neg_expression_rank_log\"].iloc[-1] - binned_means[\"neg_expression_rank_log\"].iloc[0]\n", + " \n", + " # Append the difference to the corresponding list in diff_data\n", + " diff_data[source].append(first_last_diff)\n", + "\n", + " # Remove NaN values from all bin difference lists\n", + " for source in diff_data:\n", + " diff_data[source] = [x for x in diff_data[source] if not pd.isnull(x)]\n", + "\n", + " return diff_data" + ] + }, + { + "cell_type": "markdown", + "id": "a32dbe2e-1edc-4dfc-93c3-9545c3e222a9", + "metadata": {}, + "source": [ + "#### Application" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "e86387cb-362b-43a0-909e-295356be0556", + "metadata": {}, + "outputs": [], + "source": [ + "all_tfs = ['WTM1','MIG2','RIM101','GZF3','ASH1','GAT3','TEC1','SIP3','SKN7','WTM2','HAA1','MET31','CRZ1','CHA4','ZAP1','SKO1','ACA1','FZF1','HAP2','HAP3','HAP5','INO4','ERT1','PPR1','RTG1','MOT3','CBF1','MSN2','DAL80','RTG3','GAL80','RSF2','RME1','HIR2','SIP4','HAP4','UME1','USV1','MGA1','CIN5','ROX1','XBP1','RDR1','PDR3','RLM1','SFL1','SMP1','SUT2','PHD1','SUT1','SOK2','STP2','YRR1','GAL4','LEU3','OAF1','SWI6','ACE2','TYE7','RGM1','GCN4','MIG3','STB5','RFX1','ARG80','ARG81','CST6','AZF1','SFP1','GTS1','FKH1','YOX1','FKH2','DIG1','MET28','RGT1','GCR2']\n", + "boolean_list = [True]*41 + [False]*36\n", + "cc_to_mitra_ratio_in_all = [\"cc\"]*49+[\"mitra\"]*28" + ] + }, + { + "cell_type": "markdown", + "id": "3044b2b3-c87c-43e3-988a-06cbeb3eec82", + "metadata": {}, + "source": [ + "First we will store the data for boxplots based on ranking the perturbation data by taking the average across timepoints in the mcisaac dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "fcbc6041-1103-48fc-8c49-a90a5865f3bb", + "metadata": {}, + "outputs": [], + "source": [ + "cc_mcisaac_averagebymcisaac_pearson_correlations = save_ranked_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, perturbation_sources = [\"mcisaac\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "620fe3bc-48ff-4663-81c0-8f979f9a767f", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "cc_mcisaac_averagebymcisaactimes_first_last_data = first_last_differences_store_ranked_data(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, ['mcisaac'], bins = 5)" + ] + }, + { + "cell_type": "markdown", + "id": "c1fe8989-b236-49e8-bc19-0788b6ec00a3", + "metadata": {}, + "source": [ + "Next, we will rank the perturbation data normally by the mcisaac data and store it as well." + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "deeacbc0-20e9-4a20-89ec-6d2d312a0711", + "metadata": {}, + "outputs": [], + "source": [ + "cc_mcisaac_regular_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, ['mcisaac'], 5)" + ] + }, + { + "cell_type": "markdown", + "id": "8610bead-6b6f-48e9-9bb8-40476707fdc9", + "metadata": {}, + "source": [ + "#### **2) Using Average Ranking Between mcisaac and kemmeren Perturbation Data**" + ] + }, + { + "cell_type": "markdown", + "id": "4e4561c5-68e7-4cb9-8932-aa7b9eb41a27", + "metadata": {}, + "source": [ + "An alternative approach to ranking the perturbation data is to average the rank assigned to a particular gene/TF pair between both the mcisaac 15 minute and kemmeren perturbation data. This approach now incorporates two separate perturbation datasets, with the same philosophy of averaging the ranks to ideally reduce noise and produce better data." + ] + }, + { + "cell_type": "markdown", + "id": "0277a737-3cf2-4a6c-9f6a-4e713ea44e6b", + "metadata": {}, + "source": [ + "To perform a ranking using both the mcisaac 15 minute data and the kemmeren perturbation data, we need to modify the following method so that it performs the correct operation. Then, we will rerun the same method to see how taking this average affects the outcomes in the data." + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "d6115397-dfdf-448d-b1a1-b87e851d7846", + "metadata": {}, + "outputs": [], + "source": [ + "async def process_perturbation_data_async(tf_name: str, perturbation_source: str) -> pd.DataFrame:\n", + " \"\"\"\n", + " Process perturbation data by retrieving data from McIsaac and Kemmeren datasets,\n", + " ranking genes, and calculating the average rank for each gene across both datasets.\n", + " \n", + " :param tf_name: The name of the transcription factor, e.g., \"AR080\".\n", + " :type tf_name: str\n", + " :param perturbation_source: The source of the perturbation data, e.g., \"mcisaac\".\n", + " :type perturbation_source: str\n", + " \n", + " :returns: A DataFrame containing the genes, their average rankings, and the negative log of these rankings.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " # Ensure the TF name is in uppercase to maintain consistency\n", + " tf_name_upper = tf_name.upper()\n", + " \n", + " # Initialize API for perturbation data\n", + " expression = ExpressionAPI()\n", + "\n", + " # Get the McIsaac data\n", + " expression.push_params({\"regulator_symbol\": tf_name_upper, \"source\": \"7\", \"time\": \"15\"})\n", + " expression_res = await expression.read(retrieve_files=True)\n", + " id = expression_res.get(\"metadata\")[\"id\"][0]\n", + " mcisaac_df = expression_res.get(\"data\").get(str(id))\n", + " mcisaac_df['rank'] = rankdata(-abs(mcisaac_df['effect']), method='average')\n", + " \n", + " # Get the Kemmeren data\n", + " expression2 = ExpressionAPI()\n", + " expression2.push_params({\"regulator_symbol\": tf_name_upper, \"source\": \"6\"})\n", + " expression_res2 = await expression2.read(retrieve_files=True)\n", + " id = expression_res2.get(\"metadata\")[\"id\"][0]\n", + " kemmeren_df = expression_res2.get(\"data\").get(str(id))\n", + " kemmeren_df['rank'] = rankdata(-abs(kemmeren_df['effect']), method='average')\n", + "\n", + " # Merge dataframes on 'target_locus_tag'\n", + " merged_df = pd.merge(mcisaac_df[['target_locus_tag', 'rank']], \n", + " kemmeren_df[['target_locus_tag', 'rank']], \n", + " on='target_locus_tag', \n", + " suffixes=('_mcisaac', '_kemmeren'))\n", + " \n", + " # Calculate average rank\n", + " merged_df['avg_rank'] = merged_df[['rank_mcisaac', 'rank_kemmeren']].mean(axis=1)\n", + " \n", + " # Calculate negative log of average rank\n", + " merged_df['neg_expression_rank_log'] = -np.log10(merged_df['avg_rank'])\n", + " \n", + " # Select and return the desired columns\n", + " result_df = merged_df[['target_locus_tag', 'avg_rank', 'neg_expression_rank_log']]\n", + " \n", + " return result_df" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "9ce49398-e911-4078-8b0f-01261180e146", + "metadata": {}, + "outputs": [], + "source": [ + "cc_mcisaac_averagemcisaackemmeren_pearson_correlations = save_ranked_pearson_correlation_box_plot_comparisons(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, perturbation_sources = [\"mcisaac\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "6c18190e-2e9e-4873-9d01-fce65fdc77ee", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "cc_mcisaac_averagemcisaackemmeren_first_last_data = first_last_differences_store_ranked_data(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, ['mcisaac'], bins = 5)" + ] + }, + { + "cell_type": "markdown", + "id": "8417b3f6-44eb-457b-8adf-541daddccac9", + "metadata": {}, + "source": [ + "Next, we will rank the perturbation data normally by the kemmeren data and store it as well." + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "de09e8a2-8ccb-429c-ad42-55cc8370a3b9", + "metadata": {}, + "outputs": [], + "source": [ + "cc_kemmeren_regular_first_last_data = first_last_bin_difference_box_plot_comparisons(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, ['kemmeren'], 5)" + ] + }, + { + "cell_type": "markdown", + "id": "f5513e05-82dd-42f0-acdf-d2bd0fd7d504", + "metadata": {}, + "source": [ + "#### **Boxplot Comparisons of the Ranking Approaches**" + ] + }, + { + "cell_type": "markdown", + "id": "b5066b48-ec26-442a-9dad-2a1dd00c52de", + "metadata": {}, + "source": [ + "Now let's compare the boxplots across all of the various ranking methods. We include both the data obtained from ranking using the mcisaac 15 minutes and kemmeren data as references. As a reminder, the CC + mitra dataset is used as the binding dataset across all approaches to ensure comparability. We will plot the array of boxplots for both the Pearson correlation between LRR/LRB and the boxplots for the first and last binned mean differences." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "d5ee7b1d-44ab-44ee-bc07-4999ce37bfcf", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_combined_boxplot(data: List[List[float]], labels: List[str]) -> None:\n", + " \"\"\"\n", + " Plots a single boxplot with specified labels for each dataset.\n", + " \n", + " :param data: A list of lists containing numerical data for each boxplot.\n", + " :type data: List[List[float]]\n", + " :param labels: A list containing labels for each dataset.\n", + " :type labels: List[str]\n", + " \n", + " :returns: None\n", + " :rtype: None\n", + " \"\"\"\n", + " # Create a boxplot for all datasets combined\n", + " plt.figure(figsize=(12, 8))\n", + " plt.boxplot(data, labels=labels)\n", + "\n", + " # Add a dashed line at y=0\n", + " plt.axhline(y=0, color='grey', linestyle='--')\n", + "\n", + " # Set y-axis limits\n", + " plt.ylim(-0.1, 0.4)\n", + "\n", + " # Set labels\n", + " plt.ylabel('Pearson Correlations Between LRR and LRB')\n", + " plt.xlabel('Ranking Method')\n", + " plt.title('Comparison of Pearson Correlations Between LRR and LRB Across Various Ranking Methods for 78 TFs')\n", + "\n", + " # Show plot\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "bf7e9bf1-f2a3-40c4-be42-858a87eef308", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/25/6s7q5c9j40373whzd3q5s20m0000gn/T/ipykernel_1992/4116603215.py:14: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", + " plt.boxplot(data, labels=labels)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = [cc_mcisaac_pearson_correlations['mcisaac'], cc_mcisaac_averagebymcisaac_pearson_correlations['mcisaac'], cc_mcisaac_averagemcisaackemmeren_pearson_correlations['mcisaac'], cc_kemmeren_pearson_correlations['kemmeren']]\n", + "binding_labels = [\"cc+mitra\", \"harbison\"]\n", + "perturbation_labels = [\"mcisaac\", \"avg: mcisaac timepts\", \"avg: mcisaac & kemmeren\",\"kemmeren\"]\n", + "plot_combined_boxplot(data, perturbation_labels)" + ] + }, + { + "cell_type": "markdown", + "id": "b1e74d94-493b-44c9-b722-2c216c021640", + "metadata": {}, + "source": [ + "The plot above compares the boxplots of the Pearson correlations between the LRR and LRB across the various perturbation ranking approaches. On the x-axis, the label below the boxplot indicates the method in which the perturbation data was ranked to produce the final LRR/LRB correlation value. The y-axis then plots a partial scale of the Pearson correlation values from -0.1 to 0.4 as all of the data in the boxplots is confined to this region. Upon immediate observation, it is evident that using the normal ranking of the perturbation magnitude for the mcisaac 15 minute data (leftmost boxplot) yields a similar boxplot to that of averaging the ranks of the perturbation magnitudes across the 4 mcisaac timepoints (second to left boxplot). The other two boxplots suggest that the Pearson correlations generated according to those approaches tend to show weaker Pearson correlations as the overall boxplots are shifted vertically downwards suggusting a spread of correlations that are closer to 0. However, given that the boxplots of the normal perturbation ranking on the mcisaac 15 minute data is so similar to that of averaging the rankings across the 4 mcisaac timepoints, it suggests that taking the extra step to perform this average ranking is not enough to produce a noticeable improvement in the Pearson correlations. " + ] + }, + { + "cell_type": "markdown", + "id": "a8a1453d-b531-4f47-b588-b6475a102569", + "metadata": {}, + "source": [ + "We can also plot the boxplots of the first and last binned mean differences from binning the data." + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "32ce2c6f-d07a-43b6-ba8a-13eae45c3914", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "compare_first_and_last_stored_data_box_plots([cc_mcisaac_regular_first_last_data, cc_mcisaac_averagebymcisaactimes_first_last_data,cc_mcisaac_averagemcisaackemmeren_first_last_data, cc_kemmeren_regular_first_last_data], ['mcisaac','avg: mcisaac timepts', 'avg: mcisaac & kem', \"kemmeren\"])" + ] + }, + { + "cell_type": "markdown", + "id": "9d8113d6-a898-4b0e-8fa1-54925cb98763", + "metadata": {}, + "source": [ + "Here, it appears that using the normal ranking of the perturbation effects on the mcisaac 15 minute data (leftmost boxplot) or the normal ranking of the perturbation effects on the kemmeren data (rightmost boxplot) surprisingly yield the best results. This is because we would expect the more complex ranking approaches to hopefully reduce ties in the perturbation data, leading to better rankings and clearer trends. Yet, these boxplots suggest that either using the normal mcisaac ranking, which produces a greater spread of data, or using the kemmeren normal ranking, which produces a smaller spread of data but has a lower minimum and maximum, could both be good options to rank the data. \n", + "\n", + "Overall, from these two boxplots, it appears that performing the extra steps to re-rank the data either by averaging ranks across various mcisaac timepoints or by averaging between the mcisaac and kemmeren perturbation data do not result in better trends in the data as evidenced by the boxplot comparisons. " + ] + }, + { + "cell_type": "markdown", + "id": "7ade4386-bb89-4f10-8612-03555290f6c2", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### **Which Approaches of Ranking the Binding Data Yields the Best Trends?**" + ] + }, + { + "cell_type": "markdown", + "id": "910bb41e-7a6c-41dc-a821-811ebf4953e7", + "metadata": {}, + "source": [ + "On the binding side, it's worth further exploring the which ranking method is most optimal. We essentially have 3 options: using the enrichment values, poisson pvalues, or hypergeometric pvalues to rank the binding data by. We have currently been ranking the data according to the poisson pvalues, but given that multiple experiment outcomes can produce the same pvalue, resulting to many ties that may decrease the resolution of the trends we are graphing, it is worth considering if the other two ranking methods can produce higher average ranks that result in less ties, hopefully producing more observable trends. The boxplots below are generated by taking the highest rank by each of the three methods on each TF, and generating this data across the entire Calling Cards TF pool to determine which may produce the highest average ranks." + ] + }, + { + "cell_type": "markdown", + "id": "7d3fa698-7d0a-4adf-b0d1-cab7f93aeb65", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "#### Code" + ] + }, + { + "cell_type": "code", + "execution_count": 412, + "id": "e099998e-525d-408f-90fd-1422f5cc7fcd", + "metadata": {}, + "outputs": [], + "source": [ + "async def fetch_binding_data_async(tf_name: str, is_aggregated: bool, pseudocount: int = 1) -> pd.DataFrame:\n", + " \"\"\"\n", + " Fetch binding data for a transcription factor and compute the 'effect' size.\n", + " \n", + " :param tf_name: The name of the transcription factor.\n", + " :type tf_name: str\n", + " :param is_aggregated: Indicates whether the data is aggregated.\n", + " :type is_aggregated: bool\n", + " :param pseudocount: The constant used in calculating enrichment scores to avoid division by zero, default is 1.\n", + " :type pseudocount: int\n", + " \n", + " :returns: A DataFrame containing the binding data with 'effect' computed.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + "\n", + " tf_name_upper = tf_name.upper()\n", + " pss_api_tf = PromoterSetSigAPI()\n", + " \n", + " if is_aggregated:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"datasource\": \"brent_nf_cc\", \"aggregated\": \"true\"})\n", + " else:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"workflow\": \"nf_core_callingcards_1_0_0\", \"data_usable\": \"pass\"})\n", + " \n", + " tf_pss = await pss_api_tf.read(retrieve_files=True)\n", + " id = tf_pss.get(\"metadata\")[\"id\"][0]\n", + " binding_df = tf_pss.get(\"data\").get(str(id))\n", + "\n", + " binding_data = binding_df\n", + " binding_data.rename(columns={\"callingcards_enrichment\": \"effect\"}, inplace=True)\n", + " binding_data['effect'] = (binding_data['experiment_hops'] / binding_data['experiment_total_hops']) / \\\n", + " ((binding_data['background_hops'] + pseudocount) / binding_data['background_total_hops'])\n", + "\n", + " return binding_data\n", + "\n", + "def fetch_binding_data(tf_name: str, is_aggregated: bool, pseudocount: int = 1) -> pd.DataFrame:\n", + " loop = asyncio.get_event_loop()\n", + " return loop.run_until_complete(fetch_binding_data_async(tf_name, is_aggregated, pseudocount))\n", + "\n", + "def assign_rankings(binding_data: pd.DataFrame) -> pd.DataFrame:\n", + " \"\"\"\n", + " Assign rankings to the binding data based on 'effect', 'poisson_pvalue', and 'hypergeometric_pvalue'.\n", + " \n", + " :param binding_data: The binding data to rank.\n", + " :type binding_data: pd.DataFrame\n", + " \n", + " :returns: A DataFrame with rankings assigned.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " binding_data['rank_effect'] = binding_data['effect'].rank(ascending=False, method='average')\n", + " binding_data['rank_poisson'] = binding_data['poisson_pval'].rank(ascending=True, method='average')\n", + " binding_data['rank_hypergeometric'] = binding_data['hypergeometric_pval'].rank(ascending=True, method='average')\n", + "\n", + " return binding_data\n", + "\n", + "def find_smallest_ranks(binding_data: pd.DataFrame) -> pd.Series:\n", + " \"\"\"\n", + " Find the smallest rank for each ranking method.\n", + " \n", + " :param binding_data: The binding data with rankings.\n", + " :type binding_data: pd.DataFrame\n", + " \n", + " :returns: A Series containing the smallest ranks for each method.\n", + " :rtype: pd.Series\n", + " \"\"\"\n", + " smallest_ranks = {\n", + " 'rank_effect': binding_data['rank_effect'].min(),\n", + " 'rank_poisson': binding_data['rank_poisson'].min(),\n", + " 'rank_hypergeometric': binding_data['rank_hypergeometric'].min()\n", + " }\n", + "\n", + " return pd.Series(smallest_ranks)\n", + "\n", + "def compare_tf_rankings(tfs: list, bool_list: list, binding_source: str, pseudocount: int = 1):\n", + " \"\"\"\n", + " Compare the smallest ranks across multiple transcription factors and generate boxplots.\n", + " \n", + " :param tfs: A list of transcription factor names.\n", + " :type tfs: list\n", + " :param is_aggregated: Indicates whether the data is aggregated.\n", + " :type is_aggregated: bool\n", + " :param pseudocount: The constant used in calculating enrichment scores to avoid division by zero, default is 1.\n", + " :type pseudocount: int\n", + " \"\"\"\n", + " all_ranks_effect = []\n", + " all_ranks_poisson = []\n", + " all_ranks_hypergeometric = []\n", + "\n", + " for i in range(len(tfs)):\n", + " binding_data = fetch_binding_data(tfs[i], bool_list[i], pseudocount)\n", + " ranked_data = assign_rankings(binding_data)\n", + " smallest_ranks = find_smallest_ranks(ranked_data)\n", + " \n", + " all_ranks_effect.append(smallest_ranks['rank_effect'])\n", + " all_ranks_poisson.append(smallest_ranks['rank_poisson'])\n", + " all_ranks_hypergeometric.append(smallest_ranks['rank_hypergeometric'])\n", + "\n", + " # Generate boxplots\n", + " plt.figure(figsize=(12, 8))\n", + " plt.boxplot([all_ranks_effect, all_ranks_poisson, all_ranks_hypergeometric], labels=['Effect', 'Poisson p-value', 'Hypergeometric p-value'])\n", + " plt.axhline(y=0, color='gray', linestyle='--') # Add a horizontal dotted line at y=0\n", + " plt.xlabel('Ranking Method')\n", + " plt.ylabel('Smallest Rank')\n", + " plt.title(f'Comparison of Smallest Ranks Across TFs on {binding_source} data')\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d162c322-5317-46ac-8755-802fbb9a538d", + "metadata": {}, + "source": [ + "Here we are plotting the original boxplots but ranking the binding data using the enrichment values instead of the poisson pvalues to see how the boxplots will change. First, we need to make a slight change to the process_dataframe method so that it ranks the enrichment scores instead of the pvalues" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8e0da3d0-b3a0-4305-9ec5-992f48581e46", + "metadata": {}, + "outputs": [], + "source": [ + "def process_dataframe(df: pd.DataFrame) -> pd.DataFrame:\n", + " \"\"\"\n", + " Processes a DataFrame further by calculating ranks and log transformations for expression and binding data to elucidate certain trends.\n", + " \n", + " :param df: The input DataFrame containing 'effect_perturbation' and 'pvalue_binding' columns.\n", + " :type df: pd.DataFrame\n", + " \n", + " :returns: A DataFrame that includes the original data along with new columns for expression ranks, log-transformed ranks, binding ranks, and is sorted by the negative log-transformed binding rank.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " # Calculate expression rank with average ties method\n", + " df['expression_rank'] = rankdata(-abs(df['effect_perturbation']), method='average')\n", + "\n", + " # Log transform the expression rank\n", + " df['neg_expression_rank_log'] = -np.log10(df['expression_rank'])\n", + "\n", + " # Calculate binding rank with average ties method\n", + " df['binding_rank'] = rankdata(-df['effect_binding'], method='average')\n", + "\n", + " # Calculate log transform of the binding rank\n", + " df['neg_log_rank_binding'] = -np.log10(rankdata(df['binding_rank'], method='average'))\n", + "\n", + " # Select specific columns\n", + " plotting_df = df[['effect_perturbation', 'expression_rank', 'neg_expression_rank_log', \n", + " 'pvalue_binding', 'binding_rank', 'neg_log_rank_binding']]\n", + "\n", + " # Arrange (sort) by neg_log_rank_binding in descending order\n", + " plotting_df = plotting_df.sort_values(by='neg_log_rank_binding', ascending=False)\n", + " \n", + " return plotting_df" + ] + }, + { + "cell_type": "markdown", + "id": "1e3cdcdb-7dd4-43c0-8b41-546a8a2f6e31", + "metadata": {}, + "source": [ + "#### Application" + ] + }, + { + "cell_type": "code", + "execution_count": 413, + "id": "23656d5e-9c69-4ba0-952c-736c3c7dd8f3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/25/6s7q5c9j40373whzd3q5s20m0000gn/T/ipykernel_6092/2867473121.py:94: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", + " plt.boxplot([all_ranks_effect, all_ranks_poisson, all_ranks_hypergeometric], labels=['Effect', 'Poisson p-value', 'Hypergeometric p-value'])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Using this on CallingCards Data\n", + "tfs = ['WTM1', 'MIG2', 'CAT8', 'PDR1', 'PHO4', 'RIM101', 'GZF3', 'VHR1', 'ASH1', 'GAT3','FHL1', 'TEC1', 'SIP3', 'SKN7', 'WTM2','PHO2', 'HAA1', 'ADR1', 'MET31', 'CRZ1', 'RPH1', 'CHA4', 'CAD1', 'ZAP1', 'SKO1', 'ACA1', 'FZF1', 'HAP2', 'HAP3', 'HAP5','INO4', 'ERT1', 'TOG1', 'MET4', 'PPR1', 'RTG1', 'GLN3', 'MOT3', 'AFT1', 'GIS1', 'CBF1', 'SUM1', 'MSN2', 'DAL80', 'UPC2','RTG3', 'GAL80', 'RSF2', 'RME1', 'HIR2', 'SIP4', 'GCR1', 'HAP4', 'UME1', 'MET32', 'USV1', 'MGA1', 'CIN5', 'ROX1','XBP1', 'ZNF1', 'YHP1', 'RDR1', 'PDR3', 'RLM1', 'SFL1', 'SMP1', 'SUT2', 'HAC1', 'PHD1', 'ARO80']\n", + "#Assigning the correct boolean to each TF based on whether the TF contains aggregated data in the database or not\n", + "boolean_list = [True] * 59 + [False] * 12\n", + "\n", + "compare_tf_rankings(tfs, boolean_list, \"CallingCards\")" + ] + }, + { + "cell_type": "markdown", + "id": "4c17dc0b-f006-437e-9852-166ddc9cc764", + "metadata": {}, + "source": [ + "This is quite interesting. Immediately, your attention might be drawn to the leftmost boxplot for the enrichment values. Since the y-axis is plotting the smallest rank across each TF, it appears that for the effect boxplot, almost the entire TF dataset produces a rank of 1 as the smallest rank. This means that there is a clear difference in enrichment values that reuslts in a higher rank as opposed to the other two pvalue methods, whose medians and lower quartiles hover closer to 10 than 0, suggesting greater ties at the top resulting in larger highest ranks. Seeing that using enrichment values to rank produces higher ranks in general, it is worth plotting the original data but using the negative log rank of the enrichment on the x-axis to see how the boxplots will differ. We do that now." + ] + }, + { + "cell_type": "markdown", + "id": "8b48527f-c707-4870-bc64-ea984af1aa82", + "metadata": {}, + "source": [ + "We can use our methods introduced above to compare the boxplots for the mcisaac data ranked using enrichment scores vs. perturbation scores." + ] + }, + { + "cell_type": "code", + "execution_count": 377, + "id": "787801aa-4880-4419-96a0-04026a85784c", + "metadata": {}, + "outputs": [], + "source": [ + "tfs = ['WTM1','MIG2','CAT8','PDR1','PHO4','RIM101','GZF3','ASH1','GAT3','TEC1','SIP3','SKN7','WTM2','PHO2','HAA1','ADR1','MET31','CRZ1','RPH1','CHA4','CAD1','ZAP1','SKO1','ACA1','FZF1','HAP2','HAP3','HAP5','INO4','ERT1','TOG1','PPR1','RTG1','GLN3','MOT3','AFT1','CBF1','SUM1','MSN2','DAL80','UPC2','RTG3','GAL80','RSF2','RME1','HIR2','SIP4','HAP4','UME1','MET32','USV1','MGA1','CIN5','ROX1','XBP1','ZNF1','YHP1','RDR1','PDR3','RLM1','SFL1','SMP1','SUT2','HAC1','PHD1','ARO80']\n", + "boolean_list = [True]*54 + [False]*12\n", + "cc_mcisaac_adjacent_enrichment_data = adjacent_differences_store_data(tfs, boolean_list, \"cc\", perturbation_sources = [\"mcisaac\"], bins = 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 378, + "id": "d68a2a62-687c-4457-ab29-dfc3d0e898dc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "stored_data_list = [cc_mcisaac_adjacent_enrichment_data, cc_mcisaac_adjacent_data]\n", + "labels = ['enrichment', 'pvalues']\n", + "compare_adjacent_stored_data_box_plots(stored_data_list, labels)" + ] + }, + { + "cell_type": "markdown", + "id": "313d773d-b006-43db-991a-a915adc53300", + "metadata": {}, + "source": [ + "This comparison is interesting for several reasons. First, the boxplots generated by ranking the data using enrichment values are considerably more spread out, suggesting greater variability using this method, While the medians for the first three adjacent bin differences using ranking by enrichment are slightly higher than ranking by poisson pvalues, the comparison of the rightbox boxplots shows that ranking by poisson pvalues is more optimal as the boxplot spread is mainly positive whereas the boxplot generating by ranking using enrichment has an overall neutral spread. Let us also look at how the first and last bin mean difference boxplots compare against one another." + ] + }, + { + "cell_type": "code", + "execution_count": 379, + "id": "cfe56168-9e97-4c35-bfa1-5b9e5f0c8c78", + "metadata": {}, + "outputs": [], + "source": [ + "cc_mcisaac_first_last_enrichment_data = first_last_bin_difference_box_plot_comparisons(tfs, boolean_list, \"cc\", perturbation_sources = [\"mcisaac\"], bins = 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 380, + "id": "22403d37-f439-4b79-91ed-dd4fa7e0631e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "stored_data_list = [cc_mcisaac_first_last_enrichment_data, cc_mcisaac_first_last_data]\n", + "labels = [']enrichment', 'pvalues']\n", + "compare_first_and_last_stored_data_box_plots(stored_data_list, labels)" + ] + }, + { + "cell_type": "markdown", + "id": "17ac4e83-ca34-4fa0-908f-1420eb3f3d9e", + "metadata": {}, + "source": [ + "By ranking with poisson pvalues, we obtain a boxplot with both a smaller spread and a greater distribution of data that is above 0. Again, since the data in the lower quartile to the median is roughly 0 when ranking by enrichment, this is less optimal when compared to the boxplot ranking by poisson pvalues as more of the data generally exhibits a positive trend. Thus, we conclude continuing to plot by the poisson p values is likely the most optimal way to produce an observable trend for the eventual model to learn from." + ] + }, + { + "cell_type": "markdown", + "id": "ebc20231-d60d-45ec-9445-0acc6fcecb8c", + "metadata": {}, + "source": [ + "We have shown above multiple comparisons between various binding and peturbation sources, as well as methods for ranking data. Now, we want to compile a comprehensive comparison of the first and last bin mean difference boxplots across the various binding and perturbation sources. We will use our regular method of ranking the perturbation data, and continue using the poisson pvalues when ranking the binding data. Having these boxplots together will give us the best visual comparison of how the combinations of data hold up against one another." + ] + }, + { + "cell_type": "markdown", + "id": "227dd125-d64b-451b-be50-ccfe698775ee", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## **Creating Linear Models from the Data**" + ] + }, + { + "cell_type": "markdown", + "id": "4886c9c3-791d-4f51-ac67-fa3b15c563c7", + "metadata": {}, + "source": [ + "Lastly, we are interested in understanding how certain variables in the data are related to one another. Specifically, we are interested in 3 predictor variables and 1 outcome variable: \n", + "\n", + "1) gene_symbol (predictor): the gene at which a particular TF binds to\n", + "2) TF_symbol (predictor): the transcription factor itself\n", + "3) LRB (predictor): the negative log rank of the poisson pvalues for binding\n", + "4) LRR (outcome): the negative log rank of the perturbation effect magnitudes \n", + "\n", + "In order to understand how these predictors relate to the LRR, we need to build linear models that utilize combinations of these predictors to better understand how they correlate with the outcome. In order to do this, we will aggregate the data across the 78 TFs we have previously worked with to create a large dataframe that sorts the data first by the TF_symbol, then by the gene_symbol. The LRR ranking will be performed by first assigning a rank across all of the perturbation effect magnitudes in the entire dataframe, and then taking the negative log. Since we are assigning ranks across the entire aggregated dataframe, we call this a \"global\" ranking. For the LRB, we will rank the data in two ways. The first way will be performed similar to the LRR in which a global ranking across all of the binding poisson pvalues will be performed. However, we will also perform a separate ranking of the pvalues in which we will only assign ranks within a particular TF_symbol value, meaning that for a particular TF, we will rank the binding pvalues in the same way we have perviously, and then aggregate all of these LRB values. We call this method of ranking according to segmentations in the TF_symbol data a \"local\" ranking. Thus, we will obtain two separate dataframes. In both, the LRR will be ranked globally, while the LRB will be ranked globally for one and locally for the other. For this example, we will use data for the 78 TFs derived from the CC+mitra binding dataset and the mcisaac perturbation dataset.\n", + "\n", + "Once we have obtained the data, we want to create the following linear models:\n", + "\n", + "1) Single variable models to predict the LRR\n", + "2) A joint variable model to predict the LRR\n", + "3) Models in which the effects of gene_symbol, TF_symbol, or both are removed to determine how much of the remaining variance explained is acccounted for by the LRB\n", + "\n", + "We will obtain the correlation coefficients of these models to better determine the strength of each predictor in assessing the outcome." + ] + }, + { + "cell_type": "markdown", + "id": "b910d637-f566-4d65-9580-b4675c8b196d", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### **Obtaining Data for the Linear Models**\n", + "We will define a couple of modified functions that will process the data from the desired binding/perturbation source for our set of 78 TFs. " + ] + }, + { + "cell_type": "markdown", + "id": "0de12c6f-7119-427c-b5f2-8aab4a1839d3", + "metadata": {}, + "source": [ + "#### Code" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "d81669e7-aba5-43cf-9e68-f9fcf81b4f8a", + "metadata": {}, + "outputs": [], + "source": [ + "async def process_transcription_factor_async(tf_name: str, is_aggregated: bool, binding_source: str, perturbation_source: str, pseudocount: int = 1) -> pd.DataFrame: \n", + " \"\"\"\n", + " Process transcription factor data by retrieving and merging binding and perturbation datasets.\n", + " \n", + " :param tf_name: The name of the transcription factor, e.g., \"AR080\".\n", + " :type tf_name: str\n", + " :param is_aggregated: Indicates whether the data is aggregated.\n", + " :type is_aggregated: bool\n", + " :param binding_source: The source of the binding data, e.g., \"cc\" or \"harbison\".\n", + " :type binding_source: str\n", + " :param perturbation_source: The source of the perturbation data, e.g., \"mcisaac\".\n", + " :type perturbation_source: str\n", + " :param pseudocount: The constant used in calculating enrichment and p-values scores to avoid division by zero, default is 1.\n", + " :type pseudocount: int, optional\n", + " \n", + " :returns: A DataFrame containing the combined and processed binding and perturbation data.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " # Ensure the TF name is in uppercase to maintain consistency\n", + " tf_name_upper = tf_name.upper()\n", + " \n", + " # Initialize API for binding data\n", + " pss_api_tf = PromoterSetSigAPI()\n", + "\n", + " # Access the relevant data depending on the binding source and aggregation status\n", + " if binding_source == \"cc\":\n", + " if is_aggregated:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"datasource\": \"brent_nf_cc\", \"aggregated\": \"true\"})\n", + " else:\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"workflow\": \"nf_core_callingcards_1_0_0\", \"data_usable\": \"pass\"})\n", + " elif binding_source == \"harbison\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"4\"})\n", + " elif binding_source == \"mitra\":\n", + " pss_api_tf.push_params({'regulator_symbol': tf_name_upper, \"source\": \"2\"})\n", + "\n", + " # Asynchronously read the binding data from the API\n", + " tf_pss = await pss_api_tf.read(retrieve_files=True)\n", + " # Get the ID of the retrieved binding data\n", + " id = tf_pss.get(\"metadata\")[\"id\"][0]\n", + " # Extract the binding data using the ID\n", + " binding_df = tf_pss.get(\"data\").get(str(id))\n", + "\n", + " # Initialize API for perturbation data\n", + " expression = ExpressionAPI()\n", + "\n", + " # Map perturbation source to corresponding source number\n", + " source_mapping = {\n", + " \"mcisaac\": \"7\",\n", + " \"hu_reimann\": \"5\",\n", + " \"kemmeren\": \"6\"\n", + " }\n", + " source_number = source_mapping.get(perturbation_source, \"unknown\")\n", + " \n", + " # Push parameters to retrieve the perturbation data\n", + " if perturbation_source == \"mcisaac\":\n", + " expression.push_params({\"regulator_symbol\": tf_name_upper, \"source\": source_number, \"time\": \"15\"})\n", + " else:\n", + " expression.push_params({\"regulator_symbol\": tf_name_upper, \"source\": source_number})\n", + "\n", + " # Asynchronously read the perturbation data from the API\n", + " expression_res = await expression.read(retrieve_files=True)\n", + " # Get the ID of the retrieved perturbation data\n", + " id = expression_res.get(\"metadata\")[\"id\"][0]\n", + " # Extract the perturbation data using the ID\n", + " expression_df = expression_res.get(\"data\").get(str(id))\n", + "\n", + " # Read perturbation data\n", + " perturbation_data = expression_df\n", + " # Read binding data\n", + " binding_data = binding_df\n", + "\n", + " # Rename columns in binding data for consistency and clarity\n", + " if binding_source == \"cc\":\n", + " binding_data.rename(columns={\"callingcards_enrichment\": \"effect\", \"poisson_pval\": \"pvalue\"}, inplace=True)\n", + " elif binding_source == \"harbison\":\n", + " binding_data.rename(columns={\"pval\": \"pvalue\"}, inplace=True)\n", + " elif binding_source == \"mitra\":\n", + " binding_data.rename(columns={\"callingcards_enrichment\": \"effect\", \"poisson_pval\": \"pvalue\"}, inplace=True)\n", + "\n", + " # Optional: here you can modify the pseudocount as needed. The default pseudocount is set to 1.\n", + " # Calculate the effect size for binding data using the provided formula\n", + " if binding_source == \"cc\":\n", + " binding_data['effect'] = (binding_data['experiment_hops'] / binding_data['experiment_total_hops']) / \\\n", + " ((binding_data['background_hops'] + pseudocount) / binding_data['background_total_hops'])\n", + "\n", + " # Merge the binding data and perturbation data on the 'target_locus_tag' column\n", + " combined_data = pd.merge(binding_data, perturbation_data, on='target_locus_tag', suffixes=('_binding', '_perturbation'))\n", + "\n", + " # # Assert that the length of combined_data is the minimum of the lengths of binding_data and perturbation_data\n", + " # assert len(combined_data) <= min(len(binding_data), len(perturbation_data)), \\\n", + " # f\"Length of combined_data ({len(combined_data)}) is not equal to the minimum of lengths of binding_data ({len(binding_data)}) and perturbation_data ({len(perturbation_data)})\"\n", + "\n", + " # Keep only the necessary columns in the combined data\n", + " # combined_data = combined_data[['target_locus_tag', 'effect_binding', 'effect_perturbation', 'pvalue_binding']]\n", + "\n", + " # Reorder the combined data by the smallest 'pvalue_binding' values\n", + " combined_data = combined_data.sort_values(by='pvalue_binding')\n", + "\n", + " # Apply transformations:\n", + " # - Take the absolute value of 'effect_perturbation'\n", + " # - Calculate the negative log10 of 'pvalue_binding'\n", + " # - Calculate the log10 of 'effect_binding'\n", + " combined_data['effect_perturbation'] = combined_data['effect_perturbation'].abs()\n", + " combined_data['neg_log_pvalue_binding'] = -np.log10(combined_data['pvalue_binding'])\n", + " combined_data['log_enrichment'] = np.log10(combined_data['effect_binding'])\n", + "\n", + " # Return the processed combined data as a DataFrame\n", + " return combined_data\n", + "\n", + "def aggregate_tf_data(tfs: List[str], boolean_list: List[bool], binding_source: List[str], perturbation_source:str) -> pd.DataFrame:\n", + " \"\"\"\n", + " Aggregates data for a list of transcription factors by calling the\n", + " process_transcription_factor method and combining the resulting DataFrames.\n", + " \n", + " :param tfs: A list of transcription factors.\n", + " :type tfs: List[str]\n", + " \n", + " :returns: A DataFrame containing the aggregated data.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " aggregated_data = pd.DataFrame() # Initialize an empty DataFrame\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n", + " \n", + " for i in range(len(tfs)):\n", + " #print(\"current tf:\" + str(tfs[i]))\n", + " tf_data = process_transcription_factor(tfs[i],boolean_list[i], binding_source[i], perturbation_source) # Process each TF to get its DataFrame\n", + " aggregated_data = pd.concat([aggregated_data, tf_data], ignore_index=True) # Aggregate the DataFrame\n", + "\n", + " return aggregated_data\n", + "\n", + "def resort_and_rank_dataframe(df: pd.DataFrame, method: str) -> pd.DataFrame:\n", + " \"\"\"\n", + " Resorts the dataframe by 'target_symbol' and 'regulator_symbol', then calculates\n", + " the ranks for 'effect_binding' and 'effect_perturbation' columns using a global ranking, and filters the\n", + " dataframe to include only the specified columns.\n", + " \n", + " :param df: The raw dataframe to be processed.\n", + " :type df: pd.DataFrame\n", + " \n", + " :returns: The processed dataframe with sorted and ranked columns.\n", + " :rtype: pd.DataFrame\n", + " \"\"\"\n", + " # Sort by 'target_symbol' and then by 'regulator_symbol'\n", + " df = df.sort_values(by=['regulator_symbol_perturbation','target_symbol_perturbation'])\n", + "\n", + " df['expression_rank'] = rankdata(-abs(df['effect_perturbation']), method='average')\n", + " \n", + " # Log transform the expression rank\n", + " df['LRR'] = -np.log10(df['expression_rank'])\n", + "\n", + " if method == \"global\":\n", + " # Calculate binding rank globally\n", + " df['binding_rank'] = rankdata(-abs(df['pvalue_binding']), method='average')\n", + "\n", + " elif method == \"local\":\n", + " # Calculate binding rank locally within each TF\n", + " df['binding_rank'] = df.groupby('regulator_symbol_perturbation')['pvalue_binding'].transform(lambda x: rankdata(-abs(x), method='average'))\n", + " # Calculate log transform of the binding rank\n", + " df['LRB'] = -np.log10(df['binding_rank'])\n", + "\n", + " df.rename(columns={\n", + " 'target_symbol_perturbation': 'gene_symbol',\n", + " 'regulator_symbol_perturbation': 'TF_symbol',\n", + " }, inplace=True)\n", + "\n", + " # Filter the dataframe to include only the specified columns\n", + " df_filtered = df[['TF_symbol', 'gene_symbol','LRB', 'LRR']]\n", + " \n", + " return df_filtered" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d61ce32-2f57-47ff-8543-c41c98cd5005", + "metadata": {}, + "outputs": [], + "source": [ + "raw_combined_cc_mcisaac_data = aggregate_tf_data(all_tfs, boolean_list, cc_to_mitra_ratio_in_all, \"mcisaac\")\n", + "#tfs = ['WTM1','MIG2','CAT8','PDR1','PHO4','RIM101','GZF3','ASH1','GAT3','TEC1','SIP3','SKN7','WTM2','PHO2','HAA1','ADR1','MET31','CRZ1','RPH1','CHA4','CAD1','ZAP1','SKO1','ACA1','FZF1','HAP2','HAP3','HAP5','INO4','ERT1','TOG1','PPR1','RTG1','GLN3','MOT3','AFT1','CBF1','SUM1','MSN2','DAL80','UPC2','RTG3','GAL80','RSF2','RME1','HIR2','SIP4','HAP4','UME1','MET32','USV1','MGA1','CIN5','ROX1','XBP1','ZNF1','YHP1','RDR1','PDR3','RLM1','SFL1','SMP1','SUT2','HAC1','PHD1','ARO80']\n", + "\n", + "filtered_cc_msisaac_data_global = resort_and_rank_dataframe(raw_combined_cc_mcisaac_data)\n", + "filtered_cc_msisaac_data_local = resort_and_rank_dataframe(raw_combined_cc_mcisaac_data)\n", + "\n", + "filtered_cc_msisaac_data_global.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "2dea5631-62d5-4876-8dc0-5f1bc6549e25", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TF_symbolgene_symbolLRBLRR
1325MIG2AAC1-3.683362-2.193125
1131MIG2AAC3-3.700141-3.502291
3546MIG2AAD10-3.398808-3.502291
2369MIG2AAD14-3.574263-3.502291
5240MIG2AAD15-2.982271-3.502291
\n", + "
" + ], + "text/plain": [ + " TF_symbol gene_symbol LRB LRR\n", + "1325 MIG2 AAC1 -3.683362 -2.193125\n", + "1131 MIG2 AAC3 -3.700141 -3.502291\n", + "3546 MIG2 AAD10 -3.398808 -3.502291\n", + "2369 MIG2 AAD14 -3.574263 -3.502291\n", + "5240 MIG2 AAD15 -2.982271 -3.502291" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "raw_combined_cc_mcisaac_data = aggregate_tf_data([\"MIG2\"], boolean_list, cc_to_mitra_ratio_in_all, \"mcisaac\")\n", + "\n", + "filtered_cc_msisaac_data_local_MIG2 = resort_and_rank_dataframe(raw_combined_cc_mcisaac_data, \"local\")\n", + "\n", + "filtered_cc_msisaac_data_local_MIG2.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "03ee742f-6360-4034-a46c-0df4ff3a2d62", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Creating the model for formula: LRR ~ TF_symbol\n", + "Summary for model LRR ~ TF_symbol:\n", + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: LRR R-squared: -0.000\n", + "Model: OLS Adj. R-squared: -0.000\n", + "Method: Least Squares F-statistic: nan\n", + "Date: Tue, 13 Aug 2024 Prob (F-statistic): nan\n", + "Time: 13:13:01 Log-Likelihood: -1328.4\n", + "No. Observations: 6151 AIC: 2659.\n", + "Df Residuals: 6150 BIC: 2666.\n", + "Df Model: 0 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "Intercept -3.4482 0.004 -900.481 0.000 -3.456 -3.441\n", + "==============================================================================\n", + "Omnibus: 6737.108 Durbin-Watson: 1.881\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 358938.603\n", + "Skew: 5.837 Prob(JB): 0.00\n", + "Kurtosis: 38.556 Cond. No. 1.00\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Creating the model for formula: LRR ~ LRB\n", + "Summary for model LRR ~ LRB:\n", + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: LRR R-squared: 0.000\n", + "Model: OLS Adj. R-squared: -0.000\n", + "Method: Least Squares F-statistic: 0.6444\n", + "Date: Tue, 13 Aug 2024 Prob (F-statistic): 0.422\n", + "Time: 13:13:02 Log-Likelihood: -1328.1\n", + "No. Observations: 6151 AIC: 2660.\n", + "Df Residuals: 6149 BIC: 2674.\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "Intercept -3.4720 0.030 -115.919 0.000 -3.531 -3.413\n", + "LRB -0.0071 0.009 -0.803 0.422 -0.024 0.010\n", + "==============================================================================\n", + "Omnibus: 6735.852 Durbin-Watson: 1.881\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 358578.542\n", + "Skew: 5.836 Prob(JB): 0.00\n", + "Kurtosis: 38.537 Cond. No. 28.7\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "def run_linear_model(formula, data):\n", + " print(f\"Creating the model for formula: {formula}\")\n", + " y, X = patsy.dmatrices(formula, data=data)\n", + " model = sm.OLS(y, X)\n", + " fit_model = model.fit()\n", + "\n", + " # Print the summary of the model\n", + " print(f\"Summary for model {formula}:\\n{fit_model.summary()}\\n\")\n", + "\n", + " return fit_model\n", + "\n", + "\n", + "def calculate_residuals(formula, data):\n", + " print(f\"Calculating residuals for formula: {formula}\")\n", + " y, X = patsy.dmatrices(formula, data=data)\n", + " model = sm.OLS(y, X)\n", + " fit_model = model.fit()\n", + " residuals = fit_model.resid\n", + " return residuals\n", + "\n", + "\n", + "def run_residual_model(residuals, independent_var, data, input_filename):\n", + " print(f\"Running model with residuals against {independent_var}\")\n", + " data = data.assign(residuals=residuals) # Add residuals to the data frame\n", + " formula = f\"residuals ~ {independent_var}\"\n", + " fit_model = run_linear_model(formula, data)\n", + " plot_diagnostics(\n", + " fit_model, f\"residuals_vs_{independent_var}_residual\", input_filename\n", + " )\n", + "\n", + "\n", + "def plot_diagnostics(fit_model, title_suffix, input_filename):\n", + " # Extract the base name of the input file without extension\n", + " input_basename = os.path.splitext(os.path.basename(input_filename))[0]\n", + "\n", + " # Extract fitted values and residuals\n", + " fitted_values = fit_model.fittedvalues\n", + " residuals = fit_model.resid\n", + " standardized_residuals = residuals / np.std(residuals)\n", + "\n", + " # Plot 1: Residuals vs. Fitted\n", + " plt.figure(figsize=(15, 10))\n", + " plt.scatter(fitted_values, residuals, alpha=0.5)\n", + " plt.axhline(0, color=\"gray\", linestyle=\"--\")\n", + " plt.xlabel(\"Fitted values\")\n", + " plt.ylabel(\"Residuals\")\n", + " plt.title(\"Residuals vs. Fitted \" + title_suffix)\n", + " plt.show()\n", + "\n", + "formulas = [\"LRR ~ TF_symbol\", \"LRR ~ LRB\"]\n", + "for formula in formulas:\n", + " fit_model = run_linear_model(formula, filtered_cc_msisaac_data_local_MIG2)\n", + " plot_diagnostics(fit_model, f\"({formula})_single\", \"filtered_cc_msisaac_data_local_MIG2\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8ce5c0f-84ef-47fd-b335-83afb8ce64b9", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "be194e56-fd30-44a5-94d2-897cafe8fce5", + "metadata": {}, + "source": [ + "#### Application" + ] + }, + { + "cell_type": "markdown", + "id": "81e8bd5d-a208-49af-920c-0edffa0cd893", + "metadata": {}, + "source": [ + "This is an example of how the dataframe looks based on the description above. The data is organized first by the TF_symbol, then by the gene_symbol. For this dataframe, we performed a global ranking to obtain the LRB values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "593a0fe4-7d2d-4471-aa3a-5baa9095bdb3", + "metadata": {}, + "outputs": [], + "source": [ + "#save the data locally\n", + "filtered_cc_msisaac_data_global.to_csv(\"~/Downloads/filtered_cc_msisaac_data_global.csv\", index = False)\n", + "filtered_cc_msisaac_data_local.to_csv(\"~/Downloads/filtered_cc_msisaac_data_local.csv\", index = False)" + ] + }, + { + "cell_type": "markdown", + "id": "bdd11b42-b2f7-4b86-a659-68fa0f9fc9bb", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### **Commands and Scripts for Running the Linear Models in HTCF Cluster**\n", + "Given the size of the data, running these models within this notebook isn't optimal. We used the HTCF cluster to run the scripts below. Note that running the scripts using the cluster requires the installation of singularity; you can find more information on how to use and install singularity using spack on the cluster here: https://htcf.wustl.edu/docs/software/ \n", + "Below are the files used to run the three models." + ] + }, + { + "cell_type": "markdown", + "id": "38c77c09-c457-41f3-b290-b1e799e6bc1c", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "#### Code for Files" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc33f2f4-89ca-45da-96be-bf6f5334ea33", + "metadata": {}, + "outputs": [], + "source": [ + "#code for the single variable models in the first objective\n", + "import argparse\n", + "import statsmodels.api as sm\n", + "import pandas as pd\n", + "import patsy\n", + "\n", + "\n", + "def run_linear_model(formula, data):\n", + " print(f\"Creating the model for formula: {formula}\")\n", + " y, X = patsy.dmatrices(formula, data=data)\n", + "\n", + " print(\"Fitting the model...\")\n", + " model = sm.OLS(y, X)\n", + " fit_model = model.fit()\n", + "\n", + " # Print the formula used\n", + " print(f\"Running model with formula: {formula}\")\n", + "\n", + " # Return the summary\n", + " return fit_model.summary()\n", + "\n", + "\n", + "def main():\n", + " parser = argparse.ArgumentParser(\n", + " description=\"Run linear regression models from a CSV file.\"\n", + " )\n", + " parser.add_argument(\"--input\", help=\"Path to the input CSV file.\", required=True)\n", + "\n", + " args = parser.parse_args()\n", + "\n", + " # Load the data from the CSV file\n", + " data = pd.read_csv(args.input)\n", + " print(f\"Data loaded from {args.input}\")\n", + "\n", + " # Define formulas for the different models\n", + " formulas = [\"LRR ~ gene_symbol\", \"LRR ~ TF_symbol\", \"LRR ~ LRB\"]\n", + "\n", + " # Run and print summary for each model\n", + " for formula in formulas:\n", + " print(f\"Running model: {formula}\")\n", + " summary = run_linear_model(formula, data)\n", + " print(f\"Summary:\\n{summary}\\n\")\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " main()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6930a594-5168-4acf-8bbd-37943903c6fe", + "metadata": {}, + "outputs": [], + "source": [ + "#code for the joint model in the second objective\n", + "import argparse\n", + "import statsmodels.api as sm\n", + "import pandas as pd\n", + "import patsy\n", + "\n", + "\n", + "def run_joint_linear_model(formula, data):\n", + " print(f\"Creating the joint model for formula: {formula}\")\n", + " y, X = patsy.dmatrices(formula, data=data)\n", + "\n", + " print(\"Fitting the joint model...\")\n", + " model = sm.OLS(y, X)\n", + " fit_model = model.fit()\n", + "\n", + " # Print the formula used\n", + " print(f\"Running joint model with formula: {formula}\")\n", + "\n", + " # Return the summary\n", + " return fit_model.summary()\n", + "\n", + "\n", + "def main():\n", + " parser = argparse.ArgumentParser(\n", + " description=\"Run a joint linear regression model from a CSV file.\"\n", + " )\n", + " parser.add_argument(\"--input\", help=\"Path to the input CSV file.\", required=True)\n", + "\n", + " args = parser.parse_args()\n", + "\n", + " # Load the data from the CSV file\n", + " data = pd.read_csv(args.input)\n", + " print(f\"Data loaded from {args.input}\")\n", + "\n", + " # Define the formula for the joint model\n", + " joint_formula = \"LRR ~ gene_symbol + TF_symbol + LRB\"\n", + "\n", + " # Run and print summary for the joint model\n", + " print(f\"Running joint model: {joint_formula}\")\n", + " summary = run_joint_linear_model(joint_formula, data)\n", + " print(f\"Summary of the joint model:\\n{summary}\\n\")\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " main()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3611e404-ddb1-4e3e-b869-253d21ce5c53", + "metadata": {}, + "outputs": [], + "source": [ + "#code for the linear models in the third objective\n", + "import argparse\n", + "import statsmodels.api as sm\n", + "import pandas as pd\n", + "import patsy\n", + "\n", + "\n", + "def calculate_residuals(formula, data):\n", + " print(f\"Fitting model to calculate residuals for formula: {formula}\")\n", + " y, X = patsy.dmatrices(formula, data=data)\n", + " model = sm.OLS(y, X).fit()\n", + " residuals = model.resid\n", + " return residuals\n", + "\n", + "\n", + "def run_residual_model(residuals, independent_var, data):\n", + " # Incorporating the residuals into the data used for regression\n", + " data[\"residuals\"] = residuals\n", + " formula = f\"residuals ~ {independent_var}\"\n", + " print(f\"Creating model for residuals with formula: {formula}\")\n", + " y, X = patsy.dmatrices(formula, data=data)\n", + " model = sm.OLS(y, X).fit()\n", + " return model.summary()\n", + "\n", + "\n", + "def main():\n", + " parser = argparse.ArgumentParser(\n", + " description=\"Run regression models on residuals from a CSV file.\"\n", + " )\n", + " parser.add_argument(\"--input\", help=\"Path to the input CSV file.\", required=True)\n", + "\n", + " args = parser.parse_args()\n", + "\n", + " # Load the data from the CSV file\n", + " data = pd.read_csv(args.input)\n", + " print(f\"Data loaded from {args.input}\")\n", + "\n", + " # Calculate residuals for different combinations\n", + " residuals_full = calculate_residuals(\"LRR ~ TF_symbol + gene_symbol\", data)\n", + " residuals_gene = calculate_residuals(\"LRR ~ gene_symbol\", data)\n", + " residuals_tf = calculate_residuals(\"LRR ~ TF_symbol\", data)\n", + "\n", + " # Model residuals against LRB\n", + " print(\"Modeling residuals from LRR ~ TF_symbol + gene_symbol\")\n", + " summary_full = run_residual_model(residuals_full, \"LRB\", data)\n", + " print(summary_full)\n", + "\n", + " print(\"Modeling residuals from LRR ~ gene_symbol\")\n", + " summary_gene = run_residual_model(residuals_gene, \"LRB\", data)\n", + " print(summary_gene)\n", + "\n", + " print(\"Modeling residuals from LRR ~ tf_symbol\")\n", + " summary_tf = run_residual_model(residuals_tf, \"LRB\", data)\n", + " print(summary_tf)\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " main()\n" + ] + }, + { + "cell_type": "markdown", + "id": "a2adb4e4-bc0c-4c11-9c4e-75ae68f0011d", + "metadata": {}, + "source": [ + "#### Application" + ] + }, + { + "cell_type": "markdown", + "id": "ff14c222-3631-49f5-b9bc-b62420d1b49d", + "metadata": {}, + "source": [ + "Here is an example of how to run the scripts after everything has been initialized into the cluster and ready to go." + ] + }, + { + "cell_type": "markdown", + "id": "c5306757-4989-4212-969d-38e1686d14cd", + "metadata": {}, + "source": [ + "interactive\n", + "\n", + "eval $(spack load --sh singularityce)\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 single_variable_models.py --input data/filtered_cc_mcisaac_data_global.csv\" - this has job id 17145975\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 single_variable_models.py --input data/filtered_cc_mcisaac_data_local.csv\" - this has job id 17145977\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 joint_model.py --input data/filtered_cc_mcisaac_data_global.csv\" - this has job id 17145979\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 joint_model.py --input data/filtered_cc_mcisaac_data_local.csv\" - this has job id 17145980\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 residual_models.py --input data/filtered_cc_mcisaac_data_global.csv\" - 17146057\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 residual_models.py --input data/filtered_cc_mcisaac_data_local.csv\" - 17146058\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 single_variable_models.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_local.csv\" - 17151563\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 joint_model.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_local.csv\" - 17151564\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 residual_models.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_local.csv\" - 17151565\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 single_variable_models.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_global.csv\" - 17151566\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 joint_model.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_global.csv\" - 17151567\n", + "\n", + "sbatch --mem=100G ../scripts/singularity_exec.sh statsmodel.sif \"python3 residual_models.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_global.csv\" - 17151568\n", + "\n", + "\n", + "LRR Global LRB Global\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_mcisaac_data_LRR_global_LRB_global.csv --mode 'single'\" - 17162198\n", + "\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_mcisaac_data_LRR_global_LRB_global.csv --mode 'joint'\" - 17162199\n", + "\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_mcisaac_data_LRR_global_LRB_global.csv --mode 'residual'\" - 17162200\n", + "\n", + "LRR Local LRB Global\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_global.csv --mode 'single'\" - 17162204\n", + "\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_global.csv --mode 'joint'\" - 17162205\n", + "\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_global.csv --mode 'residual'\" - 17162206\n", + "\n", + "LRR Global LRB Local\n", + "\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_mcisaac_data_LRR_global_LRB_local.csv --mode 'single'\" - 17162207\n", + "\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_mcisaac_data_LRR_global_LRB_local.csv --mode 'joint'\" - 17162208\n", + "\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_mcisaac_data_LRR_global_LRB_local.csv --mode 'residual'\" - 17162209\n", + "\n", + "LRR Local LRB Local\n", + "\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_local.csv --mode 'single'\" - 17162215\n", + "\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_local.csv --mode 'joint'\" - 17162216\n", + "\n", + "sbatch --mem=400G ../scripts/singularity_exec.sh statsmodel_plus.sif \"python3 diagnostic_plots_new.py --input data/filtered_cc_msisaac_data_LRR_local_LRB_local.csv --mode 'residual'\" - 17162217" + ] + }, + { + "cell_type": "markdown", + "id": "11cbaf6e-1535-4fbc-b06a-1f7657e7142b", + "metadata": {}, + "source": [ + "You should save the batch job number or reference the progress of your scripts using the following commands:\n", + "\n", + "check the status of how long your job has been running for:\n", + "squeue -u $USER\n", + "\n", + "check the output of your job during/after it has finished running:\n", + "cat slurm-{BATCH_JOB_NUMBER}.out" + ] + }, + { + "cell_type": "markdown", + "id": "628e0dc6-1390-4d3f-8791-2c2e81870412", + "metadata": {}, + "source": [ + "### **Table of Results for the Linear Models**\n", + "The two tables below outline the results obtained after successful execution of the scripts based on whether the binding data was ranked globally or locally. The first 3 rows in each table represent the single variable models described in the first objective. The next row represents the joint model described in the second objective, and the last 3 rows are the models described in the third objective." + ] + }, + { + "cell_type": "markdown", + "id": "d7a47d90-4bbd-4648-beca-829bc0b1edb0", + "metadata": {}, + "source": [ + "**LRR Global LRB Global**" + ] + }, + { + "cell_type": "markdown", + "id": "257c757d-335c-44d7-88b8-8986533787af", + "metadata": {}, + "source": [ + "| Model Formula | R^2 |\n", + "|----------|----------|\n", + "| LRR ~ gene_symbol | 0.040 |\n", + "| LRR ~ TF_symbol | 0.100 |\n", + "| LRR ~ LRB | 0.002 |\n", + "| LRR ~ gene_symbol + TF_symbol + LRB | 0.142 |\n", + "| resid(LRR~gene_symbol) ~ LRB | 0.002 |\n", + "| resid(LRR~TF_symbol) ~ LRB | 0.001 |\n", + "| resid(LRR~gene_symbol + TF_symbol) ~ LRB | 0.001 |" + ] + }, + { + "cell_type": "markdown", + "id": "32505e35-b7e6-4d08-a315-100f425e3682", + "metadata": {}, + "source": [ + "**LRR Global LRB Local**" + ] + }, + { + "cell_type": "markdown", + "id": "6828ca2b-878b-43c2-8892-263783ec5e7c", + "metadata": {}, + "source": [ + "| Model Formula | R^2 |\n", + "|----------|----------|\n", + "| LRR ~ gene_symbol | 0.040 |\n", + "| LRR ~ TF_symbol | 0.100 |\n", + "| LRR ~ LRB | 0.001 |\n", + "| LRR ~ gene_symbol + TF_symbol + LRB | 0.142 |\n", + "| resid(LRR~gene_symbol) ~ LRB | 0.001 |\n", + "| resid(LRR~TF_symbol) ~ LRB | 0.001 |\n", + "| resid(LRR~gene_symbol + TF_symbol) ~ LRB | 0.001 |" + ] + }, + { + "cell_type": "markdown", + "id": "96595411-b897-4807-9583-baeb26f7f740", + "metadata": {}, + "source": [ + "**LLR Local LRB Local**" + ] + }, + { + "cell_type": "markdown", + "id": "623825aa-85fc-41d6-9f19-93d1fd4c8060", + "metadata": {}, + "source": [ + "| Model Formula | R^2 |\n", + "|----------|----------|\n", + "| LRR ~ gene_symbol | 0.048 |\n", + "| LRR ~ TF_symbol | 0.010 |\n", + "| LRR ~ LRB | 0.001 |\n", + "| LRR ~ gene_symbol + TF_symbol + LRB | 0.059 |\n", + "| resid(LRR~gene_symbol) ~ LRB | 0.001 |\n", + "| resid(LRR~TF_symbol) ~ LRB | 0.001 |\n", + "| resid(LRR~gene_symbol + TF_symbol) ~ LRB | 0.001 |" + ] + }, + { + "cell_type": "markdown", + "id": "d901cdb9-aa60-4239-9999-667e71c746c8", + "metadata": {}, + "source": [ + "**LRR Local LRB Global**" + ] + }, + { + "cell_type": "markdown", + "id": "2aaa1439-f651-4d4a-9bd3-3900ac3082af", + "metadata": {}, + "source": [ + "| Model Formula | R^2 |\n", + "|----------|----------|\n", + "| LRR ~ gene_symbol | 0.048 |\n", + "| LRR ~ TF_symbol | 0.010 |\n", + "| LRR ~ LRB | 0.002 |\n", + "| LRR ~ gene_symbol + TF_symbol + LRB | 0.060 |\n", + "| resid(LRR~gene_symbol) ~ LRB | 0.001 |\n", + "| resid(LRR~TF_symbol) ~ LRB | 0.001 |\n", + "| resid(LRR~gene_symbol + TF_symbol) ~ LRB | 0.001 |" + ] + }, + { + "cell_type": "markdown", + "id": "56a980ae-1bbb-478b-bb7b-b67b1ed2ed7a", + "metadata": {}, + "source": [ + "When comparing both tables, there are only minor differences in the values for some of the linear models. This means that changing the way that the LRB is ranked (i.e. locally or globally) is ultimately rather insignificant because the LRB itself is a poor predictor of the LRR as evidenced by the low correlation coefficients in the single variable model. This also means that even after removing the effects of the other two variables, the LRB is still does not do well in accounting for the remaining explained variance based on the low correlations obtained in the last 3 rows of data. On the other hand, the TF_symbol seems to be the best predictor of the outcome as it acheives the highest correlation, which the gene_symbol has a correlation that is below half that of the TF_symbol. Interestingly, this may imply that the identify of the transcription factor itself may lend a better hand at explaining the magnitude of perturbation effects when interacting with a particular gene, as opposed to the LRB or the identity of the gene interacting with the TF. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c79588b-7a8f-437e-b601-1f7fc9c42fe0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials/generate_in_silico_data.ipynb b/docs/tutorials/generate_in_silico_data.ipynb index 89b2494..e3b06a0 100644 --- a/docs/tutorials/generate_in_silico_data.ipynb +++ b/docs/tutorials/generate_in_silico_data.ipynb @@ -621,7 +621,6 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/tutorials/visualizing_and_testing_data_generation_methods.ipynb b/docs/tutorials/visualizing_and_testing_data_generation_methods.ipynb index 3ce8ab8..7f1ede8 100644 --- a/docs/tutorials/visualizing_and_testing_data_generation_methods.ipynb +++ b/docs/tutorials/visualizing_and_testing_data_generation_methods.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -58,17 +58,23 @@ " perturbation_effect_adjustment_function_with_tf_relationships_boolean_logic\n", ")\n", "\n", - "from pytorch_lightning import Trainer, LightningModule, seed_everything\n", - "from pytorch_lightning.callbacks import ModelCheckpoint\n", - "from pytorch_lightning.loggers import CSVLogger, TensorBoardLogger\n", - "from torchsummary import summary\n", + "from pytorch_lightning import Trainer, seed_everything\n", + "from torch.utils.data import DataLoader, TensorDataset\n", + "from sklearn.metrics import explained_variance_score\n", "\n", "from yeastdnnexplorer.data_loaders.synthetic_data_loader import SyntheticDataLoader\n", "from yeastdnnexplorer.ml_models.simple_model import SimpleModel\n", "from yeastdnnexplorer.ml_models.customizable_model import CustomizableModel\n", + "from typing import Tuple, List, Dict, Union\n", "\n", - "torch.manual_seed(42) # For CPU\n", - "torch.cuda.manual_seed_all(42) # For all CUDA devices" + "seed_everything(42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Generating the Data**" ] }, { @@ -87,33 +93,29 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "n_genes = 3000\n", - "\n", "bound = [0.5, 0.5, 0.5, 0.5, 0.5]\n", "n_sample = [1, 1, 2, 2, 4]\n", "\n", - "# this will be a list of length 10 with a GenePopulation object in each element\n", + "# Generate gene populations\n", "gene_populations_list = []\n", "for bound_proportion, n_draws in zip(bound, n_sample):\n", " for _ in range(n_draws):\n", " gene_populations_list.append(generate_gene_population(n_genes, bound_proportion))\n", " \n", "# Generate binding data for each gene population\n", - "binding_effect_list = [generate_binding_effects(gene_population)\n", - " for gene_population in gene_populations_list]\n", + "binding_effect_list = [generate_binding_effects(gene_population) for gene_population in gene_populations_list]\n", "\n", "# Calculate p-values for binding data\n", "binding_pvalue_list = [generate_pvalues(binding_data) for binding_data in binding_effect_list]\n", "\n", + "# Combine binding data into a tensor\n", "binding_data_combined = [torch.stack((gene_population.labels, binding_effect, binding_pval), dim=1)\n", - " for gene_population, binding_effect, binding_pval\n", - " in zip (gene_populations_list, binding_effect_list, binding_pvalue_list)]\n", - "\n", - "# Stack along a new dimension (dim=1) to create a tensor of shape [num_genes, num_TFs, 3]\n", + " for gene_population, binding_effect, binding_pval in zip(gene_populations_list, binding_effect_list, binding_pvalue_list)]\n", "binding_data_tensor = torch.stack(binding_data_combined, dim=1)" ] }, @@ -123,7 +125,7 @@ "source": [ "Now we define our experiment, this function will return the average perturbation effects (across n_iterations iterations) for each TF for a specific gene for each of the 4 data generation method we have at our disposal. Due to the randomness in the generated data, we need to find the averages over a number of iterations to get the true common values.\n", "\n", - "We also need to define dictionaries of TF relationships for our third and fourth methods of generating perturbation data, see `generate_in_silico_data.ipynb` for an explanation of what these represent and how they are used / structured. The documentation in `generate_data.py` may be helpful as well." + "We also need to define dictionaries of TF relationships for our third and fourth methods of generating perturbation data, see generate_in_silico_data.ipynb for an explanation of what these represent and how they are used / structured. The documentation in generate_data.py may be helpful as well." ] }, { @@ -184,11 +186,10 @@ " dep_mean_adjustment_scores = torch.zeros(num_tfs)\n", " boolean_logic_scores = torch.zeros(num_tfs)\n", "\n", - " # we generate perturbation effects for each TF on each iteration and then add them to the running totals\n", " for i in range(n_iterations):\n", " # Method 1: Generate perturbation effects without mean adjustment\n", " perturbation_effects_list_no_mean_adjustment = [generate_perturbation_effects(binding_data_tensor[:, tf_index, :].unsqueeze(1), tf_index=0) \n", - " for tf_index in range(sum(n_sample))]\n", + " for tf_index in range(num_tfs)]\n", " perturbation_effects_list_no_mean_adjustment = torch.stack(perturbation_effects_list_no_mean_adjustment, dim=1)\n", "\n", " # Method 2: Generate perturbation effects with normal mean adjustment\n", @@ -213,7 +214,6 @@ " max_mean_adjustment=10.0,\n", " )\n", "\n", - " # take absolute values since we only care about the magnitude of the effects\n", " no_mean_adjustment_scores += abs(perturbation_effects_list_no_mean_adjustment[GENE_IDX, :])\n", " normal_mean_adjustment_scores += abs(perturbation_effects_list_normal_mean_adjustment[GENE_IDX, :])\n", " dep_mean_adjustment_scores += abs(perturbation_effects_list_dep_mean_adjustment[GENE_IDX, :])\n", @@ -222,7 +222,6 @@ " if (i + 1) % 5 == 0:\n", " print(f\"iteration {i+1} completed\")\n", " \n", - " # divide by the number of iterations to get the averages\n", " no_mean_adjustment_scores /= n_iterations\n", " normal_mean_adjustment_scores /= n_iterations\n", " dep_mean_adjustment_scores /= n_iterations\n", @@ -233,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -276,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -348,7 +347,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -375,7 +374,7 @@ " num_genes=4000,\n", " bound_mean=3.0,\n", " bound=[0.5] * 5,\n", - " n_sample=[1, 1, 2, 2, 4], # sum of this is num of tfs\n", + " n_sample=[1, 1, 2, 2, 4],\n", " val_size=0.1,\n", " test_size=0.1,\n", " random_state=42,\n", @@ -597,7 +596,7 @@ "version_minor": 0 }, "text/plain": [ - "Sanity Checking: | …" + "Sanity Checking: | | 0/? [00:00